/*

cache?: boolean

/**

code?: number

/**

content?: T

/**

cookie?: { key: string; value: string; path?: string }

/**

filePath?: string

/**

headers?: http.OutgoingHttpHeaders

/**

mime?: string

/**

redirect?: string

/**

stream?: Readable

/**

query?: Query

readonly auth?: AuthType

readonly cert?: string

readonly certKey?: string

readonly commit?: string

readonly host?: string

readonly password?: string

readonly port?: number

readonly socket?: string

base: string

requestPath: string

query: querystring.ParsedUrlQuery

fullPath: string

originalPath: string

readonly auth: AuthType

readonly password?: string

readonly commit: string

protected readonly rootPath = path.resolve(__dirname, "../..")

public constructor(protected readonly options: HttpProviderOptions) {}

public dispose(): void {

// No default behavior.

}

/**

public abstract handleWebSocket(

route: Route,

request: http.IncomingMessage,

socket: net.Socket,

head: Buffer

): Promise<true | undefined>

/**

public abstract handleRequest(route: Route, request: http.IncomingMessage): Promise<HttpResponse | undefined>

/**

public base(route: Route): string {

const depth = ((route.fullPath + "/").match(/\//g) || []).length

return normalize("./" + (depth > 1 ? "../".repeat(depth - 1) : ""))

}

protected get isDev(): boolean {

return this.options.commit === "development"

}

/**

protected async getResource(...parts: string[]): Promise<HttpResponse> {

const filePath = path.join(...parts)

return { content: await fs.readFile(filePath), filePath }

}

/**

protected async getUtf8Resource(...parts: string[]): Promise<HttpStringFileResponse> {

const filePath = path.join(...parts)

return { content: await fs.readFile(filePath, "utf8"), filePath }

}

/**

protected async getTarredResource(...parts: string[]): Promise<HttpResponse> {

const filePath = path.join(...parts)

return { stream: tarFs.pack(filePath), filePath, mime: "application/tar", cache: true }

}

/**

protected ensureGet(request: http.IncomingMessage): void {

if (request.method !== "GET") {

throw new HttpError(`Unsupported method ${request.method}`, HttpCode.BadRequest)

}

}

/**

protected ensureAuthenticated(request: http.IncomingMessage): void {

if (!this.authenticated(request)) {

throw new HttpError("Unauthorized", HttpCode.Unauthorized)

}

}

/**

protected queryOrDefault(value: string | string[] | undefined, def: string): string {

if (Array.isArray(value)) {

value = value[0]

}

return typeof value !== "undefined" ? value : def

}

/**

protected authenticated(request: http.IncomingMessage, payload?: AuthPayload): string | boolean {

switch (this.options.auth) {

case AuthType.None:

return true

case AuthType.Password:

if (typeof payload === "undefined") {

payload = this.parseCookies<AuthPayload>(request)

}

if (this.options.password && payload.key) {

for (let i = 0; i < payload.key.length; ++i) {

if (safeCompare(payload.key[i], this.options.password)) {

return payload.key[i]

}

}

}

return false

default:

throw new Error(`Unsupported auth type ${this.options.auth}`)

}

}

/**

protected getData(request: http.IncomingMessage): Promise<string | undefined> {

return request.method === "POST" || request.method === "DELETE"

? new Promise<string>((resolve, reject) => {

let body = ""

const onEnd = (): void => {

off() // eslint-disable-line @typescript-eslint/no-use-before-define

resolve(body || undefined)

}

const onError = (error: Error): void => {

off() // eslint-disable-line @typescript-eslint/no-use-before-define

reject(error)

}

const onData = (d: Buffer): void => {

body += d

if (body.length > 1e6) {

onError(new HttpError("Payload is too large", HttpCode.LargePayload))

request.connection.destroy()

}

}

const off = (): void => {

request.off("error", onError)

request.off("data", onError)

request.off("end", onEnd)

}

request.on("error", onError)

request.on("data", onData)

request.on("end", onEnd)

})

: Promise.resolve(undefined)

}

/**

protected parseCookies<T extends Cookies>(request: http.IncomingMessage): T {

const cookies: { [key: string]: string[] } = {}

if (request.headers.cookie) {

request.headers.cookie.split(";").forEach((keyValue) => {

const [key, value] = split(keyValue, "=")

if (!cookies[key]) {

cookies[key] = []

}

cookies[key].push(decodeURI(value))

})

}

return cookies as T

}

private heartbeatTimer?: NodeJS.Timeout

private heartbeatInterval = 60000

private lastHeartbeat = 0

public constructor(private readonly heartbeatPath: string, private readonly isActive: () => Promise<boolean>) {}

/**

public beat(): void {

const now = Date.now()

if (now - this.lastHeartbeat >= this.heartbeatInterval) {

logger.trace("heartbeat")

fs.outputFile(this.heartbeatPath, "").catch((error) => {

logger.warn(error.message)

})

this.lastHeartbeat = now

if (typeof this.heartbeatTimer !== "undefined") {

clearTimeout(this.heartbeatTimer)

}

this.heartbeatTimer = setTimeout(() => {

this.isActive().then((active) => {

if (active) {

this.beat()

}

})

}, this.heartbeatInterval)

}

}

protected readonly server: http.Server | https.Server

private listenPromise: Promise<string | null> | undefined

public readonly protocol: "http" | "https"

private readonly providers = new Map<string, HttpProvider>()

private readonly heart: Heart

public constructor(private readonly options: HttpServerOptions) {

this.heart = new Heart(path.join(xdgLocalDir, "heartbeat"), async () => {

const connections = await this.getConnections()

logger.trace(`${connections} active connection${plural(connections)}`)

return connections !== 0

})

this.protocol = this.options.cert ? "https" : "http"

if (this.protocol === "https") {

this.server = httpolyglot.createServer(

{

cert: this.options.cert && fs.readFileSync(this.options.cert),

key: this.options.certKey && fs.readFileSync(this.options.certKey),

},

this.onRequest

)

} else {

this.server = http.createServer(this.onRequest)

}

}

public dispose(): void {

this.providers.forEach((p) => p.dispose())

}

public async getConnections(): Promise<number> {

return new Promise((resolve, reject) => {

this.server.getConnections((error, count) => {

return error ? reject(error) : resolve(count)

})

})

}

/**

public registerHttpProvider<T extends HttpProvider>(endpoint: string, provider: HttpProvider0<T>): void

public registerHttpProvider<A1, T extends HttpProvider>(

endpoint: string,

provider: HttpProvider1<A1, T>,

a1: A1

): void

// eslint-disable-next-line @typescript-eslint/no-explicit-any

public registerHttpProvider(endpoint: string, provider: any, a1?: any): void {

endpoint = endpoint.replace(/^\/+|\/+$/g, "")

if (this.providers.has(`/${endpoint}`)) {

throw new Error(`${endpoint} is already registered`)

}

if (/\//.test(endpoint)) {

throw new Error(`Only top-level endpoints are supported (got ${endpoint})`)

}

this.providers.set(

`/${endpoint}`,

new provider(

{

auth: this.options.auth || AuthType.None,

commit: this.options.commit,

password: this.options.password,

},

a1

)

)

}

/**

public listen(): Promise<string | null> {

if (!this.listenPromise) {

this.listenPromise = new Promise((resolve, reject) => {

this.server.on("error", reject)

this.server.on("upgrade", this.onUpgrade)

const onListen = (): void => resolve(this.address())

if (this.options.socket) {

this.server.listen(this.options.socket, onListen)

} else {

this.server.listen(this.options.port, this.options.host, onListen)

}

})

}

return this.listenPromise

}

/**

public address(): string | null {

const address = this.server.address()

const endpoint =

typeof address !== "string" && address !== null

? (address.address === "::" ? "localhost" : address.address) + ":" + address.port

: address

return endpoint && `${this.protocol}://${endpoint}`

}

private onRequest = async (request: http.IncomingMessage, response: http.ServerResponse): Promise<void> => {

try {

this.heart.beat()

const route = this.parseUrl(request)

const payload = this.maybeRedirect(request, route) || (await route.provider.handleRequest(route, request))

if (!payload) {

throw new HttpError("Not found", HttpCode.NotFound)

}

response.writeHead(payload.redirect ? HttpCode.Redirect : payload.code || HttpCode.Ok, {

"Content-Type": payload.mime || getMediaMime(payload.filePath),

...(payload.redirect ? { Location: payload.redirect } : {}),

...(request.headers["service-worker"] ? { "Service-Worker-Allowed": route.provider.base(route) } : {}),

...(payload.cache ? { "Cache-Control": "public, max-age=31536000" } : {}),

...(payload.cookie

? {

"Set-Cookie": `${payload.cookie.key}=${payload.cookie.value}; Path=${payload.cookie.path ||

}

: {}),

...payload.headers,

})

if (payload.stream) {

payload.stream.on("error", (error: NodeJS.ErrnoException) => {

response.writeHead(error.code === "ENOENT" ? HttpCode.NotFound : HttpCode.ServerError)

response.end(error.message)

})

payload.stream.pipe(response)

} else if (typeof payload.content === "string" || payload.content instanceof Buffer) {

response.end(payload.content)

} else if (payload.content && typeof payload.content === "object") {

response.end(JSON.stringify(payload.content))

} else {

response.end()

}

} catch (error) {

let e = error

if (error.code === "ENOENT" || error.code === "EISDIR") {

e = new HttpError("Not found", HttpCode.NotFound)

}

logger.debug(error.stack)

response.writeHead(typeof e.code === "number" ? e.code : HttpCode.ServerError)

response.end(error.message)

}

}

/**

private maybeRedirect(request: http.IncomingMessage, route: ProviderRoute): HttpResponse | undefined {

const redirect = (path: string): string => {

Object.keys(route.query).forEach((key) => {

if (typeof route.query[key] === "undefined") {

delete route.query[key]

}

})

// If we're handling TLS ensure all requests are redirected to HTTPS.

return this.options.cert

? `${this.protocol}://${request.headers.host}`

: "" +

normalize(`${route.provider.base(route)}/${path}`, true) +

(Object.keys(route.query).length > 0 ? `?${querystring.stringify(route.query)}` : "")

}

// Redirect to HTTPS if we're handling the TLS.

if (this.options.cert && !(request.connection as tls.TLSSocket).encrypted) {

return { redirect: redirect(route.fullPath) }

}

// Redirect our indexes to a trailing slash so relative paths in the served

// HTML will operate against the base path properly.

if (route.requestPath === "/index.html" && !route.originalPath.endsWith("/") && this.providers.has(route.base)) {

return { redirect: redirect(route.fullPath + "/") }

}

return undefined

}

private onUpgrade = async (request: http.IncomingMessage, socket: net.Socket, head: Buffer): Promise<void> => {

try {

this.heart.beat()

socket.on("error", () => socket.destroy())

if (this.options.cert && !(socket as tls.TLSSocket).encrypted) {

throw new HttpError("HTTP websocket", HttpCode.BadRequest)

}

if (!request.headers.upgrade || request.headers.upgrade.toLowerCase() !== "websocket") {

throw new HttpError("HTTP/1.1 400 Bad Request", HttpCode.BadRequest)

}

const route = this.parseUrl(request)

if (!route.provider) {

throw new HttpError("Not found", HttpCode.NotFound)

}

if (!(await route.provider.handleWebSocket(route, request, socket, head))) {

throw new HttpError("Not found", HttpCode.NotFound)

}

} catch (error) {

socket.destroy(error)

logger.warn(`discarding socket connection: ${error.message}`)

}

}

/**

private parseUrl(request: http.IncomingMessage): ProviderRoute {

const parse = (fullPath: string): { base: string; requestPath: string } => {

const match = fullPath.match(/^(\/?[^/]*)(.*)$/)

let [, /* ignore */ base, requestPath] = match ? match.map((p) => p.replace(/\/+$/, "")) : ["", "", ""]

if (base.indexOf(".") !== -1) {

// Assume it's a file at the root.

requestPath = base

base = "/"

} else if (base === "") {

// Happens if it's a plain `domain.com`.

base = "/"

}

requestPath = requestPath || "/index.html"

// Allow for a versioned static endpoint. This lets us cache every static

// resource underneath the path based on the version without any work and

// without adding query parameters which have their own issues.

if (/^\/static-/.test(base)) {

base = "/static"

}

return { base, requestPath }

}

const parsedUrl = request.url ? url.parse(request.url, true) : { query: {}, pathname: "" }

const originalPath = parsedUrl.pathname || ""

const fullPath = normalize(originalPath)

const { base, requestPath } = parse(fullPath)

// Providers match on the path after their base so we need to account for

// that by shifting the next base out of the request path.

let provider = this.providers.get(base)

if (base !== "/" && provider) {

return { ...parse(requestPath), fullPath, query: parsedUrl.query, provider, originalPath }

}

// Fall back to the top-level provider.

provider = this.providers.get("/")

if (!provider) {

throw new Error(`No provider for ${base}`)

}

return { base, fullPath, requestPath, query: parsedUrl.query, provider, originalPath }

}