index.js

//@ts-check
const https = require('node:https')
const http = require('node:http')
const fs = require('node:fs')
const path = require('node:path')

const fsPromises = fs.promises
const location = process.argv[1]
const isDev = (process.argv[2] === '--dev')

if(process.argv[2] !== undefined && !isDev) {
    console.error('process.argv[2] is defined and it is not "--dev"')
    process.exit(1)
}

let myPath
if(fs.lstatSync(location).isDirectory()) {
    myPath = location
} else {
    myPath = path.dirname(location)
}
myPath += path.sep

/**
 * @param {http.IncomingMessage} request 
 * @returns {Promise<string>}
 */
const getPayloadString = function(request) {
    return new Promise((resolve) => {
        let body = ''
        request.on('data', (chunk) => {
            body += chunk
        }).on('end', () => {
            resolve(body)
        })
    })
}

/**
 * @param {Parameters<import("./index.d.ts")>[0]} options
 */
module.exports = function ({
    publicDir,
    port,

    hostname,
    routes,
    httpsOptions,
}) {
    publicDir = path.resolve(myPath, publicDir)

    hostname ??= 'localhost'
    routes ??= {}
    httpsOptions ??= {key: '', cert: ''}

    let /** @type {https} */ protocol
    const options = {}
    if(httpsOptions.key && httpsOptions.cert) {
        options.key = fs.readFileSync(path.resolve(myPath, httpsOptions.key))
        options.cert = fs.readFileSync(path.resolve(myPath, httpsOptions.cert))
        protocol = https
    } else {
        // @ts-expect-error
        protocol = http
    }

    const cache = {}

    if (!isDev) {
        const cacheFilesRecursively = function(dir, baseUrl = '') {
            const entries = fs.readdirSync(dir, { withFileTypes: true })
            for (const entry of entries) {
                const entryPath = path.join(dir, entry.name)
                const entryUrl = path.posix.join(baseUrl, entry.name)

                if (entry.isDirectory()) {
                    cacheFilesRecursively(entryPath, entryUrl)
                } else if (entry.isFile()) {
                    cache[`/${entryUrl}`] = fs.readFileSync(entryPath)
                }
            }
        }

        try {
            cacheFilesRecursively(publicDir)
        } catch(_) {}
    }

    const server = protocol.createServer(options, async (req, res) => {
        if (req.url === undefined) throw new Error("req.url is undefined")
        req.url = req.url.split('?')[0]

        if(req.url in routes) {
            const route = routes[req.url]
            if (typeof route === 'string') {
                res.writeHead(302, {
                    location: route
                })
                res.end()
                return
            }

            let result
            try {
                const payloadString = await getPayloadString(req)

                let requestPayload
                if (payloadString !== "") {
                    requestPayload = JSON.parse(payloadString)
                }

                result = await route(requestPayload)
            } catch(_) {
                res.writeHead(500)
                res.end("Internal server error")
                return
            }

            if (typeof result === 'string') {
                res.end(result)
                return
            }

            res.writeHead(500)
            res.end("Internal server error")
            return
        }

        if(req.url.endsWith('.js') || req.url.endsWith('.mjs')) {
            res.setHeader('content-type', 'text/javascript')
        }
        
        if(req.url.endsWith('.wasm')) {
            res.setHeader('content-type', 'application/wasm')
        }

        if (!isDev) {
            if (cache[req.url]) {
                res.end(cache[req.url])
                return
            }

            if (req.url.includes('.')) {
                res.writeHead(404)
                res.end("404 Not Found")
                return
            }

            const urlWithoutIndex = path.posix.join(req.url, 'index.html')
            if (cache[urlWithoutIndex]) {
                res.end(cache[urlWithoutIndex])
                return
            }

            res.writeHead(404)
            res.end("404 Not Found")
            return
        }

        fsPromises.readFile(path.resolve(publicDir, req.url.substring(1)))
            .then((buffer) => {
                res.end(buffer)
            })
            .catch((_) => {
                if (req.url === undefined) throw new Error("req.url is undefined")

                if (req.url.includes('.')) {
                    res.writeHead(404)
                    res.end("404 Not Found")
                    return
                }

                fsPromises.readFile(path.resolve(publicDir, req.url.substring(1), 'index.html'))
                    .then((buffer) => {
                        res.end(buffer)
                    })
                    .catch((_) => {
                        res.writeHead(404)
                        res.end("404 Not Found")
                        return
                    })
            })
    })

    server.listen(port, hostname, () => {
        const address = server.address()
        if (address === null) {
            throw new Error("server.address() is null")
        }
        if (typeof address === 'string') {
            throw new Error("server.address() is a string, which is not expected")
        }
        console.log(`Listening on ${hostname}:${address.port}`)
    })
}