jopijs 0.0.1

package/dist/@core/jopiEasy.js

@@ -0,0 +1,983 @@
+// noinspection JSUnusedGlobalSymbols
+import path from "node:path";
+import fsc from "node:fs";
+import * as jk_app from "jopi-toolkit/jk_app";
+import * as jk_timer from "jopi-toolkit/jk_timer";
+import * as jk_term from "jopi-toolkit/jk_term";
+import * as jk_events from "jopi-toolkit/jk_events";
+import { ServerFetch } from "./serverFetch.js";
+import { getLetsEncryptCertificate } from "./letsEncrypt.js";
+import { UserStore_WithLoginPassword } from "./userStores.js";
+import { getBundlerConfig } from "./bundler/config.js";
+import { serverInitChronos } from "./internalTools.js";
+import { getInMemoryCache, initMemoryCache } from "./caches/InMemoryCache.js";
+import { SimpleFileCache } from "./caches/SimpleFileCache.js";
+import { ProcessUrlResult, WebSiteCrawler } from "jopijs/crawler";
+import { JopiRequest } from "./jopiRequest.js";
+import { WebSiteImpl, WebSiteOptions } from "./jopiWebSite.js";
+import { getServer } from "./jopiServer.js";
+import { HTTP_VERBS } from "./publicTools.js";
+import { getPackageJsonConfig } from "jopijs/loader-tools";
+import { initLinker } from "./linker.js";
+import { logServer_startApp } from "./_logs.js";
+serverInitChronos.start("jopiEasy lib");
+class JopiApp {
+    _isStartAppSet = false;
+    startApp(importMeta, f) {
+        async function doStart() {
+            await jk_app.waitServerSideReady();
+            await jk_app.declareAppStarted();
+            let res = f(new JopiEasy());
+            if (res instanceof Promise)
+                await res;
+        }
+        if (this._isStartAppSet)
+            throw "App is already started";
+        this._isStartAppSet = true;
+        const logEnd = logServer_startApp.beginInfo("Starting Application");
+        jk_app.setApplicationMainFile(importMeta.filename);
+        doStart().then(logEnd);
+    }
+}
+let gWebSiteCreated = false;
+export class JopiEasy {
+    getDefaultUrl() {
+        let config = getPackageJsonConfig();
+        if (config.webSiteListeningUrl)
+            return config.webSiteListeningUrl;
+        if (config.webSiteUrl)
+            return config.webSiteUrl;
+        throw new Error("Invalid package.json configuration. 'jopi.webSiteUrl' or 'jopi.webSiteListeningUrl' must be set");
+    }
+    create_creatWebSiteServer(url, ref) {
+        if (gWebSiteCreated)
+            throw new Error("WebSite already created");
+        gWebSiteCreated = true;
+        if (!url) {
+            url = this.getDefaultUrl();
+        }
+        const res = new JopiEasyWebSite_ExposePrivate(url);
+        if (ref)
+            ref.webSite = res;
+        return res;
+    }
+    create_webSiteDownloader(urlOrigin) {
+        if (gWebSiteCreated)
+            throw new Error("WebSite already created");
+        gWebSiteCreated = true;
+        if (!urlOrigin) {
+            urlOrigin = this.getDefaultUrl();
+        }
+        return new CrawlerDownloader(urlOrigin);
+    }
+}
+export class RefFor_WebSite {
+    webSite;
+    waitWebSiteReady() {
+        if (!this.webSite)
+            return Promise.reject("website not set");
+        return new Promise((resolve) => {
+            this.webSite?.on_webSiteReady(resolve);
+        });
+    }
+}
+export const jopiApp = new JopiApp();
+//region Crawler
+class CrawlerDownloader {
+    urlOrigin;
+    _options = {};
+    _outputDir = "www-out";
+    _startUrl;
+    _urlPrefix;
+    _ignoreIfAlreadyDownloaded;
+    _onUrlProcessed;
+    _filter_canIgnoreIfAlreadyCrawled;
+    constructor(urlOrigin) {
+        this.urlOrigin = urlOrigin;
+        const urlInfos = new URL(urlOrigin);
+        this._urlPrefix = urlInfos.origin;
+        this._outputDir = path.resolve(process.cwd(), "www_" + urlInfos.hostname);
+    }
+    /**
+     * Define the directory where files will be downloaded.
+     * If not set, that it takes the current url and the hostname.
+     */
+    set_outputDir(outputDir) {
+        this._outputDir = outputDir;
+        return this;
+    }
+    /**
+     * Define the start point url.
+     * If not set, the default is "/".
+     * @param url
+     */
+    set_startUrl(url) {
+        this._startUrl = this.normalizeUrl(url);
+        return this;
+    }
+    normalizeUrl(url) {
+        if (url.startsWith(this._urlPrefix)) {
+            return url.substring(this._urlPrefix.length);
+        }
+        return url;
+    }
+    /**
+     * Add url with must be crawled.
+     * Is required if these urls aren't reachable from the start point.
+     */
+    set_extraUrls(urlList) {
+        urlList = urlList.map(u => this.normalizeUrl(u));
+        this._options.scanThisUrls = [...new Set([...this._options.scanThisUrls || [], ...urlList])];
+        return this;
+    }
+    /**
+     * Allow avoiding downloading again a resource if already in cache.
+     * @param value
+     */
+    setOption_ignoreIfAlreadyDownloaded(value = true) {
+        this._ignoreIfAlreadyDownloaded = value;
+        return this;
+    }
+    /**
+     * Set a function which is called when a URL has been processed.
+     *
+     * @param listener - A function that received information about the URL and his processing state.
+     */
+    on_urlProcessed(listener) {
+        this._onUrlProcessed = listener;
+        return this;
+    }
+    /**
+     * Sets a filter function to determine whether a URL can be downloaded.
+     *
+     * @param filter - A function that takes the URL as a string and a boolean flag
+     *                 indicating if it is a resource, and returns a boolean indicating
+     *                 whether the URL can be downloaded.
+     *
+     *                 Returns true if the url can be processed.
+     */
+    setFilter_canProcessThisUrl(filter) {
+        this._options.canDownload = filter;
+        return this;
+    }
+    setFilter_canIgnoreIfAlreadyDownloaded(filter) {
+        if (this._ignoreIfAlreadyDownloaded === undefined) {
+            this._ignoreIfAlreadyDownloaded = true;
+        }
+        this._filter_canIgnoreIfAlreadyCrawled = filter;
+        return this;
+    }
+    async START_DOWNLOAD() {
+        const downloader = this;
+        const crawler = new WebSiteCrawler(this.urlOrigin, {
+            outputDir: this._outputDir,
+            onUrlProcessed(infos) {
+                switch (infos.state) {
+                    case ProcessUrlResult.IGNORED:
+                        console.log("👎  Website downloader, url IGNORED:", infos.sourceUrl);
+                        break;
+                    case ProcessUrlResult.ERROR:
+                        console.log("❌  Website downloader, url ERROR:", infos.sourceUrl);
+                        break;
+                    case ProcessUrlResult.OK:
+                        console.log("✅  Website downloader, url DOWNLOADED:", infos.sourceUrl);
+                        break;
+                    case ProcessUrlResult.REDIRECTED:
+                        console.log("🚫  Website downloader, url REDIRECTED:", infos.sourceUrl);
+                        break;
+                }
+                if (downloader._onUrlProcessed) {
+                    downloader._onUrlProcessed(infos);
+                }
+            },
+            canIgnoreIfAlreadyCrawled(url, infos) {
+                if (!downloader._ignoreIfAlreadyDownloaded)
+                    return false;
+                if (downloader._filter_canIgnoreIfAlreadyCrawled) {
+                    return downloader._filter_canIgnoreIfAlreadyCrawled(url, infos);
+                }
+                return true;
+            },
+            ...this._options
+        });
+        console.log("Downloading website", this.urlOrigin);
+        await crawler.start(this._startUrl);
+        console.log("Download finished for", this.urlOrigin);
+    }
+}
+//endregion
+//region CreateServerFetch
+class CreateServerFetch {
+    options;
+    createNextStep(options) {
+        return new CreateServerFetch_NextStep(options);
+    }
+    /**
+     * The server will be call with his IP and not his hostname
+     * which will only be set in the headers. It's required when
+     * the DNS doesn't pinpoint to the god server.
+     */
+    useIp(serverOrigin, ip, options) {
+        let rOptions = ServerFetch.getOptionsFor_useIP(serverOrigin, ip, options);
+        this.options = rOptions;
+        return this.createNextStep(rOptions);
+    }
+    useOrigin(serverOrigin, options) {
+        let rOptions = ServerFetch.getOptionsFor_useOrigin(serverOrigin, options);
+        this.options = rOptions;
+        return this.createNextStep(rOptions);
+    }
+}
+class CreateServerFetch_NextStep {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    set_weight(weight) {
+        this.options.weight = weight;
+        return this;
+    }
+    set_isMainServer() {
+        return this.set_weight(1);
+    }
+    set_isBackupServer() {
+        return this.set_weight(0);
+    }
+    on_beforeRequesting(handler) {
+        this.options.beforeRequesting = handler;
+        return this;
+    }
+    on_ifServerIsDown(handler) {
+        this.options.ifServerIsDown = async (_fetcher, data) => {
+            const { builder, getResult } = IfServerDownBuilder.newBuilder(data);
+            let r = handler(builder);
+            if (r instanceof Promise)
+                await r;
+            let options = getResult();
+            if (options) {
+                const res = {
+                    newServer: ServerFetch.useAsIs(options),
+                    newServerWeight: options?.weight
+                };
+                return res;
+            }
+            return undefined;
+        };
+        return this;
+    }
+    do_startServer(handler) {
+        this.options.doStartServer = handler;
+        return this;
+    }
+    do_stopServer(handler) {
+        this.options.doStopServer = handler;
+        return this;
+    }
+}
+class IfServerDownBuilder extends CreateServerFetch {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    static newBuilder(data) {
+        const b = new IfServerDownBuilder(data);
+        return { builder: b, getResult: () => b.options };
+    }
+}
+export class JopiEasyWebSite {
+    origin;
+    hostName;
+    webSite;
+    options = {};
+    afterHook = [];
+    beforeHook = [];
+    internals;
+    _isWebSiteReady = false;
+    fileServerOptions;
+    events = jk_events.defaultEventGroup;
+    constructor(url) {
+        setTimeout(async () => {
+            await this.initWebSiteInstance();
+        }, 1);
+        const urlInfos = new URL(url);
+        this.hostName = urlInfos.hostname; // 127.0.0.1
+        this.origin = urlInfos.origin; // https://127.0.0.1
+        this.internals = {
+            options: this.options,
+            origin: this.origin,
+            hostName: this.hostName,
+            afterHook: this.afterHook,
+            beforeHook: this.beforeHook
+        };
+        this.options.onWebSiteReady = [() => {
+                this._isWebSiteReady = true;
+            }];
+        if (this.origin.startsWith("https://")) {
+            this.internals.beforeHook.push(async () => {
+                if (!gIsSslCertificateDefined) {
+                    this.internals.options.certificate = useCertificateStore("certs", this.hostName);
+                }
+            });
+        }
+        this.fileServerOptions = {
+            rootDir: "public",
+            replaceIndexHtml: true,
+            onNotFound: req => req.res_returnError404_NotFound()
+        };
+        this.internals.afterHook.push(async (webSite) => {
+            webSite.onGET("/**", req => {
+                return req.file_serveFromDir(this.fileServerOptions.rootDir, {
+                    replaceIndexHtml: this.fileServerOptions.replaceIndexHtml,
+                    onNotFound: this.fileServerOptions.onNotFound
+                });
+            });
+        });
+    }
+    async initWebSiteInstance() {
+        const onWebSiteCreate = (h) => {
+            this.internals.afterHook.push(h);
+        };
+        if (!this.webSite) {
+            await initLinker(this, onWebSiteCreate);
+            for (let hook of this.beforeHook)
+                await hook();
+            this.webSite = new WebSiteImpl(this.origin, this.options);
+            for (const hook of this.afterHook) {
+                try {
+                    await hook(this.webSite);
+                }
+                catch (e) {
+                    if (e instanceof Error) {
+                        jk_term.logBgRed("Error when initializing website", this.origin);
+                        jk_term.logRed(e.message);
+                        console.log(e.stack);
+                    }
+                    else {
+                        console.error("Error when initializing website", this.origin);
+                        jk_term.logRed("|-", e.message);
+                    }
+                    process.exit(1);
+                }
+            }
+            if (!giIsCorsDisabled) {
+                this.webSite.enableCors([this.webSite.welcomeUrl, ...gCorsConstraints]);
+            }
+            myServer.setWebsite(this.webSite);
+            await autoStartServer();
+        }
+        if (this.internals.onHookWebSite) {
+            this.internals.onHookWebSite(this.webSite);
+        }
+    }
+    hook_webSite(hook) {
+        this.internals.onHookWebSite = hook;
+        return this;
+    }
+    DONE_createWebSite() {
+        return jopiApp;
+    }
+    add_httpCertificate() {
+        return new CertificateBuilder(this, this.internals);
+    }
+    fastConfigure_fileServer(options) {
+        this.fileServerOptions = options;
+        return this;
+    }
+    configure_fileServer() {
+        const parent = this;
+        const me = {
+            set_rootDir: (rootDir) => {
+                this.fileServerOptions.rootDir = rootDir;
+                return me;
+            },
+            set_onNotFound: (handler) => {
+                this.fileServerOptions.onNotFound = handler;
+                return me;
+            },
+            DONE_configure_fileServer: () => {
+                return parent;
+            }
+        };
+        return me;
+    }
+    configure_jwtTokenAuth() {
+        const builder = new JwtTokenAuth_Builder(this, this.internals);
+        return {
+            step_setPrivateKey: (privateKey) => builder.setPrivateKey_STEP(privateKey)
+        };
+    }
+    fastConfigure_jwtTokenAuth(privateKey, store) {
+        const builder = new JwtTokenAuth_Builder(this, this.internals);
+        let config = builder.setPrivateKey_STEP(privateKey).step_setUserStore();
+        if (store instanceof Array) {
+            config.use_simpleLoginPassword().addMany(store);
+        }
+        else {
+            config.use_customStore(store);
+        }
+        return this;
+    }
+    add_SseEvent(path, handler) {
+        this.internals.afterHook.push((webSite) => {
+            webSite.addSseEVent(path, handler);
+        });
+        return this;
+    }
+    configure_postCss() {
+        const parent = this;
+        const me = {
+            setPlugin: (handler) => {
+                getBundlerConfig().postCss.initializer = handler;
+                return me;
+            },
+            END_configure_postCss() {
+                return parent;
+            }
+        };
+        return me;
+    }
+    configure_behaviors() {
+        const parent = this;
+        const me = {
+            removeTrailingSlashs(value = true) {
+                parent.options.removeTrailingSlash = value;
+                return me;
+            },
+            DONE_configure_behaviors() {
+                return parent;
+            }
+        };
+        return me;
+    }
+    configure_cache() {
+        return new WebSite_CacheBuilder(this, this.internals);
+    }
+    configure_middlewares() {
+        return new WebSite_MiddlewareBuilder(this, this.internals);
+    }
+    configure_bundler() {
+        const parent = this;
+        const me = {
+            dontEmbed_ReactJS: () => {
+                me.dontEmbedThis("react", "react-dom");
+                return me;
+            },
+            dontEmbedThis: (...packages) => {
+                let config = getBundlerConfig();
+                if (!config.embed.dontEmbedThis)
+                    config.embed.dontEmbedThis = [];
+                config.embed.dontEmbedThis.push(...packages);
+                return me;
+            },
+            END_configure_bundler() {
+                return parent;
+            }
+        };
+        return me;
+    }
+    configure_tailwindProcessor() {
+        const parent = this;
+        const me = {
+            disableTailwind: () => {
+                getBundlerConfig().tailwind.disable = true;
+                return me;
+            },
+            setGlobalCssContent: (template) => {
+                getBundlerConfig().tailwind.globalCssContent = template;
+                return me;
+            },
+            setConfig: (config) => {
+                getBundlerConfig().tailwind.config = config;
+                return me;
+            },
+            /**
+             * Allows adding extra-sources files to scan.
+             * Can also be motifs. Ex: "./myDir/*.{js,ts,jsx,tsx}"
+             */
+            addExtraSourceFiles: (...files) => {
+                const config = getBundlerConfig().tailwind;
+                if (!config.extraSourceFiles)
+                    config.extraSourceFiles = [];
+                config.extraSourceFiles.push(...files);
+                return me;
+            },
+            setGlobalCssFilePath: (filePath) => {
+                const config = getBundlerConfig().tailwind;
+                config.globalCssFilePath = filePath;
+                return me;
+            },
+            END_configure_tailwindProcessor() {
+                return parent;
+            }
+        };
+        return me;
+    }
+    add_sourceServer() {
+        return new WebSite_AddSourceServerBuilder(this, this.internals);
+    }
+    add_specialPageHandler() {
+        return new WebSite_AddSpecialPageHandler(this, this.internals);
+    }
+    on_webSiteReady(listener) {
+        if (this._isWebSiteReady) {
+            listener();
+            return;
+        }
+        this.options.onWebSiteReady.push(listener);
+        return this;
+    }
+    configure_cors() {
+        return new WebSite_ConfigureCors(this);
+    }
+    fastConfigure_cors(allowedHosts) {
+        const b = new WebSite_ConfigureCors(this);
+        if (allowedHosts) {
+            allowedHosts.forEach(o => b.add_allowedHost(o));
+        }
+        return this;
+    }
+}
+class JopiEasyWebSite_ExposePrivate extends JopiEasyWebSite {
+    isWebSiteReady() {
+        return this._isWebSiteReady;
+    }
+    getInternals() {
+        return this.internals;
+    }
+}
+class WebSite_ConfigureCors {
+    webSite;
+    constructor(webSite) {
+        this.webSite = webSite;
+    }
+    add_allowedHost(hostName) {
+        try {
+            let url = new URL(hostName);
+            gCorsConstraints.push(url.origin);
+        }
+        catch {
+            throw new Error(`Invalid host name: ${hostName}. Must be a valid URL.`);
+        }
+        return this;
+    }
+    disable_cors() {
+        giIsCorsDisabled = true;
+        return this;
+    }
+    DONE_configure_cors() {
+        return this.webSite;
+    }
+}
+class WebSite_AddSpecialPageHandler {
+    webSite;
+    internals;
+    constructor(webSite, internals) {
+        this.webSite = webSite;
+        this.internals = internals;
+    }
+    END_add_specialPageHandler() {
+        return this.webSite;
+    }
+    on_404_NotFound(handler) {
+        this.internals.afterHook.push(async (webSite) => {
+            webSite.on404_NotFound(handler);
+        });
+        return this;
+    }
+    on_500_Error(handler) {
+        this.internals.afterHook.push(async (webSite) => {
+            webSite.on500_Error(handler);
+        });
+        return this;
+    }
+    on_401_Unauthorized(handler) {
+        this.internals.afterHook.push(async (webSite) => {
+            webSite.on401_Unauthorized(handler);
+        });
+        return this;
+    }
+}
+class WebSite_AddSourceServerBuilder extends CreateServerFetch {
+    webSite;
+    internals;
+    serverFetch;
+    constructor(webSite, internals) {
+        super();
+        this.webSite = webSite;
+        this.internals = internals;
+        this.internals.afterHook.push(async (webSite) => {
+            if (this.serverFetch) {
+                webSite.addSourceServer(this.serverFetch);
+            }
+        });
+    }
+    createNextStep(options) {
+        return new WebSite_AddSourceServerBuilder_NextStep(this.webSite, this.internals, options);
+    }
+    END_add_sourceServer() {
+        return this.webSite;
+    }
+    add_sourceServer() {
+        return new WebSite_AddSourceServerBuilder(this.webSite, this.internals);
+    }
+}
+class WebSite_AddSourceServerBuilder_NextStep extends CreateServerFetch_NextStep {
+    webSite;
+    internals;
+    constructor(webSite, internals, options) {
+        super(options);
+        this.webSite = webSite;
+        this.internals = internals;
+        this.internals.afterHook.push(async (webSite) => {
+            webSite.addSourceServer(ServerFetch.useAsIs(this.options));
+        });
+    }
+    END_add_sourceServer() {
+        return this.webSite;
+    }
+    add_sourceServer() {
+        return new WebSite_AddSourceServerBuilder(this.webSite, this.internals);
+    }
+}
+class WebSite_MiddlewareBuilder {
+    webSite;
+    internals;
+    constructor(webSite, internals) {
+        this.webSite = webSite;
+        this.internals = internals;
+    }
+    add_middleware(method, middleware, options) {
+        this.internals.afterHook.push(async (webSite) => {
+            webSite.addGlobalMiddleware(method, middleware, options);
+        });
+        return this;
+    }
+    add_postMiddleware(method, middleware, options) {
+        this.internals.afterHook.push(async (webSite) => {
+            webSite.addGlobalPostMiddleware(method, middleware, options);
+        });
+        return this;
+    }
+    END_configure_middlewares() {
+        return this.webSite;
+    }
+}
+class WebSite_CacheBuilder {
+    webSite;
+    internals;
+    cache;
+    onFakeNoUser;
+    rules = [];
+    constructor(webSite, internals) {
+        this.webSite = webSite;
+        this.internals = internals;
+        this.internals.afterHook.push(async (webSite) => {
+            webSite.setCacheRules(this.rules);
+            if (this.onFakeNoUser) {
+                webSite.setOnFakeNoUser(this.onFakeNoUser);
+            }
+            if (this.cache) {
+                webSite.setCache(this.cache);
+            }
+        });
+    }
+    on_fakeNoUser(listener) {
+        this.onFakeNoUser = listener;
+        return this;
+    }
+    use_inMemoryCache(options) {
+        if (options)
+            initMemoryCache(options);
+        this.cache = getInMemoryCache();
+        return this;
+    }
+    use_fileSystemCache(rootDir) {
+        this.cache = new SimpleFileCache(rootDir);
+        return this;
+    }
+    add_cacheRules(rules) {
+        this.rules.push(rules);
+        return this;
+    }
+    END_configure_cache() {
+        return this.webSite;
+    }
+}
+//endregion
+//region Server starting
+let gIsAutoStartDone = false;
+async function autoStartServer() {
+    if (gIsAutoStartDone)
+        return;
+    gIsAutoStartDone = true;
+    await jk_timer.tick(5);
+    await myServer.startServer();
+}
+const myServer = getServer();
+//endregion
+//region Reverse proxy
+class ReverseProxyBuilder {
+    webSite;
+    internals;
+    constructor(url, ref) {
+        this.webSite = new JopiEasyWebSite_ExposePrivate(url);
+        if (ref)
+            ref.webSite = this.webSite;
+        this.internals = this.webSite.getInternals();
+        this.internals.afterHook.push(async (webSite) => {
+            const handler = req => {
+                req.headers.set('X-Forwarded-Proto', req.urlInfos.protocol.replace(':', ''));
+                req.headers.set('X-Forwarded-Host', req.urlInfos.host);
+                const clientIp = req.coreServer.requestIP(req.coreRequest)?.address;
+                req.headers.set("X-Forwarded-For", clientIp);
+                return req.proxy_directProxyToServer();
+            };
+            HTTP_VERBS.forEach(verb => {
+                webSite.onVerb(verb, "/**", handler);
+            });
+        });
+    }
+    add_target() {
+        const { builder, getOptions } = ReverseProxyBuilder_AddTarget.newBuilder(this);
+        this.internals.afterHook.push(async (webSite) => {
+            let options = getOptions();
+            if (options) {
+                webSite.addSourceServer(ServerFetch.useAsIs(options));
+            }
+        });
+        return builder;
+    }
+    DONE_create_reverseProxy() {
+        return this.webSite;
+    }
+}
+class ReverseProxyBuilder_AddTarget extends CreateServerFetch {
+    parent;
+    static newBuilder(parent) {
+        const b = new ReverseProxyBuilder_AddTarget(parent);
+        return { builder: b, getOptions: () => b.options };
+    }
+    constructor(parent) {
+        super();
+        this.parent = parent;
+    }
+    DONE_add_target() {
+        return this.parent;
+    }
+}
+class ReverseProxyBuilder_AddTarget_NextStep extends CreateServerFetch_NextStep {
+    parent;
+    options;
+    constructor(parent, options) {
+        super(options);
+        this.parent = parent;
+        this.options = options;
+    }
+    DONE_add_target() {
+        return this.parent;
+    }
+}
+//endregion
+//region TLS Certificates
+//region CertificateBuilder
+let gIsSslCertificateDefined = false;
+function useCertificateStore(dirPath, hostName) {
+    dirPath = path.join(dirPath, hostName);
+    let cert = "";
+    let key = "";
+    try {
+        cert = path.resolve(dirPath, "certificate.crt.key");
+        fsc.statfsSync(cert);
+    }
+    catch {
+        console.error("Certificat file not found: ", cert);
+    }
+    try {
+        key = path.resolve(dirPath, "certificate.key");
+        fsc.statfsSync(key);
+    }
+    catch {
+        console.error("Certificat key file not found: ", key);
+    }
+    return { key, cert };
+}
+class CertificateBuilder {
+    parent;
+    internals;
+    constructor(parent, internals) {
+        this.parent = parent;
+        this.internals = internals;
+    }
+    generate_localDevCert(saveInDir = "certs") {
+        gIsSslCertificateDefined = true;
+        this.internals.beforeHook.push(async () => {
+            try {
+                this.internals.options.certificate = await myServer.createDevCertificate(this.internals.hostName, saveInDir);
+            }
+            catch {
+                console.error(`Can't create ssl certificate for ${this.internals.hostName}. Is mkcert tool installed ?`);
+            }
+        });
+        return {
+            DONE_add_httpCertificate: () => this.parent
+        };
+    }
+    use_dirStore(dirPath) {
+        gIsSslCertificateDefined = true;
+        this.internals.options.certificate = useCertificateStore(dirPath, this.internals.hostName);
+        return { DONE_add_httpCertificate: () => this.parent };
+    }
+    generate_letsEncryptCert(email) {
+        gIsSslCertificateDefined = true;
+        const params = { email };
+        this.internals.afterHook.push(async (webSite) => {
+            await getLetsEncryptCertificate(webSite, params);
+        });
+        return new LetsEncryptCertificateBuilder(this.parent, params);
+    }
+}
+//endregion
+//region LetsEncryptCertificateBuilder
+class LetsEncryptCertificateBuilder {
+    parent;
+    params;
+    constructor(parent, params) {
+        this.parent = parent;
+        this.params = params;
+    }
+    DONE_add_httpCertificate() {
+        return this.parent;
+    }
+    enable_production(value = true) {
+        this.params.isProduction = value;
+        return this;
+    }
+    disable_log() {
+        this.params.log = false;
+        return this;
+    }
+    set_certificateDir(dirPath) {
+        this.params.certificateDir = dirPath;
+        return this;
+    }
+    force_expireAfter_days(dayCount) {
+        this.params.expireAfter_days = dayCount;
+        return this;
+    }
+    force_timout_sec(value) {
+        this.params.timout_sec = value;
+        return this;
+    }
+    if_timeOutError(handler) {
+        this.params.onTimeoutError = handler;
+        return this;
+    }
+}
+//endregion
+class JwtTokenAuth_Builder {
+    parent;
+    internals;
+    constructor(parent, internals) {
+        this.parent = parent;
+        this.internals = internals;
+    }
+    FINISH() {
+        return {
+            DONE_configure_jwtTokenAuth: () => this.parent
+        };
+    }
+    //region setPrivateKey_STEP (BEGIN / root)
+    setPrivateKey_STEP(privateKey) {
+        this.internals.afterHook.push(async (webSite) => {
+            webSite.setJwtSecret(privateKey);
+        });
+        return {
+            step_setUserStore: () => this.setUserStore_STEP()
+        };
+    }
+    //endregion
+    //region setUserStore_STEP
+    loginPasswordStore;
+    setUserStore_STEP() {
+        const self = this;
+        return {
+            use_simpleLoginPassword: () => {
+                this.loginPasswordStore = new UserStore_WithLoginPassword();
+                this.internals.afterHook.push(async (webSite) => {
+                    this.loginPasswordStore.setAuthHandler(webSite);
+                });
+                return this.useSimpleLoginPassword_BEGIN();
+            },
+            use_customStore(store) { return self.useCustomStore_BEGIN(store); }
+        };
+    }
+    _setUserStore_NEXT() {
+        return {
+            stepConfigure: () => this.stepConfigure(),
+            DONE_setUserStore: () => this.FINISH(),
+        };
+    }
+    //region useCustomStore
+    useCustomStore_BEGIN(store) {
+        this.internals.afterHook.push(async (webSite) => {
+            webSite.setAuthHandler(store);
+        });
+        return {
+            DONE_use_customStore: () => this.useCustomStore_DONE()
+        };
+    }
+    useCustomStore_DONE() {
+        return this._setUserStore_NEXT();
+    }
+    //endregion
+    //region useSimpleLoginPassword
+    useSimpleLoginPassword_BEGIN() {
+        return this._useSimpleLoginPassword_REPEAT();
+    }
+    useSimpleLoginPassword_DONE() {
+        return this._setUserStore_NEXT();
+    }
+    _useSimpleLoginPassword_REPEAT() {
+        return {
+            getStoreRef: (h) => {
+                h(this.loginPasswordStore);
+                return this._useSimpleLoginPassword_REPEAT();
+            },
+            addOne: (login, password, userInfos) => this.useSimpleLoginPassword_addOne(login, password, userInfos),
+            addMany: (users) => this.useSimpleLoginPassword_addMany(users),
+            DONE_use_simpleLoginPassword: () => this.useSimpleLoginPassword_DONE()
+        };
+    }
+    useSimpleLoginPassword_addOne(login, password, userInfos) {
+        this.loginPasswordStore.add({ login, password, userInfos });
+        return this._useSimpleLoginPassword_REPEAT();
+    }
+    useSimpleLoginPassword_addMany(users) {
+        users.forEach(e => this.loginPasswordStore.add(e));
+        return this._useSimpleLoginPassword_REPEAT();
+    }
+    //endregion
+    //endregion
+    //region setTokenStore
+    stepConfigure() {
+        return {
+            set_cookieDuration: (expirationDuration_hours) => this.setTokenStore_useCookie(expirationDuration_hours),
+            DONE_stepConfigure: () => this.FINISH()
+        };
+    }
+    setTokenStore_useCookie(expirationDuration_hours = 3600) {
+        this.internals.afterHook.push(async (webSite) => {
+            webSite.setJwtTokenStore((_token, cookieValue, req) => {
+                req.cookie_addCookieToRes("authorization", cookieValue, { maxAge: jk_timer.ONE_HOUR * expirationDuration_hours });
+            });
+        });
+        return this.stepConfigure();
+    }
+}
+//endregion
+//region Config
+let gCorsConstraints = [];
+let giIsCorsDisabled = false;
+//endregion
+//# sourceMappingURL=jopiEasy.js.map