IPost/routes/userfiles.js

import ejs from "ejs"
import { LRUCache as LRU } from "lru-cache"
import { minify as min_js } from "uglify-js"
import Clean from 'clean-css';
import Minifier from 'html-minifier-terser';
import { web_version } from "unsafe_encrypt";
import { existsSync, readFileSync, readFile } from "fs"

export const setup = function (router, con, server) {

    const increaseUSERCall = server.increaseUSERCall
    const dir = server.dirname + "/"

    ejs.cache = new LRU({ max: 20 })

    const load_var_cache = new LRU({
        max: 20,
        maxSize: 10000,
        sizeCalculation: (value) => {
            return value.length
        },
        ttl: 1000 * 60,
        allowStale: true,
        updateAgeOnGet: true,
        updateAgeOnHas: true
    })

    function load_var(filePath) {
        if (load_var_cache.has(filePath)) {
            return load_var_cache.get(filePath);
        }

        if (!existsSync(filePath)) {
            console.log(1, 'Tried loading non-existent file', filePath);
            load_var_cache.set(filePath, '');
            return '';
        }

        let output = readFileSync(filePath);

        if (filePath.endsWith('.js')) {
            output = min_js(output.toString()).code;
        } else if (filePath.endsWith('.css')) {
            const { styles } = new Clean({}).minify(output.toString());
            output = styles;
        }
        load_var_cache.set(filePath, output);
        return output;
    }

    function get_channels() {
        return new Promise(function (resolve, reject) {
            let sql = `select post_receiver_name from ipost.posts where post_is_private = '0' group by post_receiver_name;`;
            con.query(sql, [], function (err, result) {
                if (err) reject(err)

                let out = []

                for (let channel of result) {
                    if (channel.post_receiver_name === "") continue;
                    out[out.length] = channel.post_receiver_name
                }

                resolve(out)
            });
        })
    }

    const appId_Cache = new LRU({ max: 20, ttl: 1000 * 60 * 15 }) //cache for 15 minutes
    function getAppWithId(appid) {
        appid = Number(appid)
        return new Promise((res, rej) => {
            if (isNaN(appid)) {
                res({})
                return
            }
            if (appId_Cache.has(appid)) {
                res(appId_Cache.get(appid) || {})
                return
            }
            con.query("SELECT * FROM ipost.application WHERE application_id=?", [appid], (err, result) => {
                if (err) {
                    console.error(err)
                    rej({})
                    return
                }
                appId_Cache.set(appid, result[0])
                res(result[0] || {})
            })
        })
    }

    let global_page_variables = {
        globalcss: load_var("./css/global.css"),
        httppostjs: load_var("./js/httppost.js"),
        navbar: load_var("./extra_modules/navbar.html"),
        markdownjs: load_var("./js/markdown.js"),
        htmlescapejs: load_var("./js/htmlescape.js"),
        warnmessagejs: load_var("./js/warn_message.js"),
        loadfile: load_var,
        getChannels: get_channels,
        encryptJS: min_js(web_version().toString()).code,
        cookiebanner: `<script id="cookieyes" type="text/javascript" src="https://cdn-cookieyes.com/client_data/3cf33f6b631f3587bf83813b/script.js" async></script>`,
        getPID: server.global_page_variables.getPID,
        getDMPID: server.global_page_variables.getDMPID,
        unauthorized_description: "Chat now by creating an account on IPost",
        hcaptcha_sitekey: server.hcaptcha.sitekey,
        getAppWithId: getAppWithId
    }



    async function handleUserFiles(request, response, overrideurl) {
        if (!increaseUSERCall(request, response)) return;
        if (typeof overrideurl !== "string") overrideurl = undefined;

        let originalUrl = overrideurl
            || request.params.file
            || request.originalUrl.split("?").shift(); //backup in case anything goes wrong

        let path = ""
        if (existsSync(dir + "views/" + originalUrl)) {
            path = dir + "views/" + originalUrl
            //send .txt files as plaintext to help browsers interpret it correctly
            if (originalUrl.endsWith(".txt")) {
                response.set('Content-Type', 'text/plain');
                readFile(path, (err, data) => {
                    if (err) return
                    response.send(data)
                })
                return
            }
        }
        if (existsSync(dir + "views/" + originalUrl + "index.html")) {
            path = dir + "views/" + originalUrl + "index.html"
        }
        if (existsSync(dir + "views/" + originalUrl + ".html")) {
            path = dir + "views/" + originalUrl + ".html"
        }
        if (existsSync(dir + "views" + originalUrl + ".html")) {
            path = dir + "views" + originalUrl + ".html"
        }

        if (path !== "" && originalUrl !== "favicon.ico" && originalUrl !== "api_documentation" && originalUrl !== "api_documentation.html") {
            console.log(originalUrl)
            global_page_variables.user = { "username": response.locals.username, "bio": response.locals.bio, "avatar": response.locals.avatar }
            global_page_variables.query = request.query
            if (originalUrl === "authorize") {
                global_page_variables.application = await getAppWithId(request.query.id)
            }
            ejs.renderFile(path, global_page_variables, { async: true }, async function (err, str) {
                str = await str
                err = await err
                if (err) {
                    console.log(1, err)
                    response.status(500)
                    response.send("error")
                    //TODO: make error page
                    return
                }
                try {
                    str = await Minifier.minify(str, {
                        removeComments: true,
                        removeCommentsFromCDATA: true,
                        removeCDATASectionsFromCDATA: true,
                        collapseWhitespace: true,
                        collapseBooleanAttributes: true,
                        removeAttributeQuotes: true,
                        removeRedundantAttributes: true,
                        useShortDoctype: true,
                        removeEmptyAttributes: true
                    })
                } catch (ignored) {
                    console.log(2, "error minifying", originalUrl);
                }

                try {
                    response.send(str)
                } catch (err) {
                    console.error(err)
                }
            })
            return;
        }

        if (originalUrl === "api_documentation" || originalUrl === "api_documentation.html") {
            response.set('Cache-Control', 'public, max-age=2592000');
            response.set('Content-Type', 'text/html')
            response.send(load_var("./views/api_documentation.html"))
            return
        }

        if (originalUrl === "favicon.ico") {
            response.set('Cache-Control', 'public, max-age=2592000');
            response.sendFile(dir + "/views/favicon.ico")
            return
        }

        console.log(5, "no file found", originalUrl);
        try {
            response.status(404).send("No file with that name found");
        } catch (err) {
            console.error(err)
        }
    }

    /**
    * Handle default URI as /index (interpreted redirect: "localhost" -> "localhost/index" )
    */
    router.get("/", (req, res) => {
        req.params.file = "index"
        handleUserFiles(req, res, "/index")
    });

    router.get("/:file", handleUserFiles);
    router.get("/:folder/:file", (req, res) => {
        req.params.file = req.params.folder + "/" + req.params.file
        handleUserFiles(req, res)
    });
}