firefly-compiler 0.5.39 → 0.5.40

package/webserver/WebServer.ff

@@ -1,647 +1,647 @@
-capability WebServer(
-    intenalSystem: NodeSystem
-    internalHost: String
-    internalPort: Int
-    mutable internalJsWebSockets: JsValue
-    mutable internalJsWildcard: JsValue
-    mutable internalJsHosts: Array[JsValue]
-    mutable internalJsApp: JsValue
-)
-
-class WebRequest[T](
-    internalJsApp: JsValue
-    internalJsContext: JsValue
-    internalMethod: String
-    internalPath: String
-    internalQuery: String
-    internalHeaders: StringMap[String]
-    internalJsResponse: JsValue
-    internalResponse: Option[T]
-    internalResponseHeaders: StringMap[String]
-    internalResponseChunks: Array[JsValue]
-    mutable internalResponseStatus: String
-    mutable internalCloseConnection: Bool
-    mutable internalResolveFlush: JsValue
-    mutable internalContentSize: Int
-    mutable internalResponded: Bool
-)
-
-capability WebResponse {}
-
-data MultipartField {}
-
-capability WebSocketConnection(
-    messages: Queue[JsValue]
-    listeners: Queue[Unit => Unit]
-    mutable webSocket: JsValue
-)
-
-new(
-    system: NodeSystem
-    host: String
-    port: Int
-): WebServer {
-    WebServer(system, host, port, system.js().null(), system.js().null(), [].toArray(), system.js().null())
-}
-
-extend self: WebServer {
-    
-    enableWebSockets(
-        maxPayloadBytes: Int = 16384
-        maxBackpressureBytes: Int = 65536
-        closeDueToMaxBackpressureBytes: Bool = False
-        maxLifetime: Option[Duration] = None
-        idleTimeout: Option[Duration] = None
-    ) {
-        self.internalJsWebSockets = self.intenalSystem.js().object()
-        self.internalJsWebSockets.set("maxPayloadLength", maxPayloadBytes)
-        self.internalJsWebSockets.set("maxBackpressureBytes", maxBackpressureBytes)
-        self.internalJsWebSockets.set("closeOnBackpressureLimit", closeDueToMaxBackpressureBytes)
-        maxLifetime.each {self.internalJsWebSockets.set("maxLifetime", (_.seconds / 60).round().toInt())}
-        idleTimeout.each {self.internalJsWebSockets.set("idleTimeout", _.seconds.round().toInt())}
-    }
-    
-    addHost(
-        hostname: String
-        key: Option[Path] = None
-        certificate: Option[Path] = None
-        certificateAuthority: Option[Path] = None
-        passphrase: Option[String] = None
-        dhParameters: Option[Path] = None
-        ciphers: Option[String] = None
-        preferLowMemoryUsage: Bool = False
-    ) {
-        let object = self.intenalSystem.js().object().with("hostname", hostname)
-        key.each {object.set("key_file_name", _.absolute())}
-        certificate.each {object.set("cert_file_name", _.absolute())}
-        certificateAuthority.each {object.set("ca_file_name", _.absolute())}
-        passphrase.each {object.set("passphrase", _)}
-        dhParameters.each {object.set("dh_params_file_name", _.absolute())}
-        ciphers.each {object.set("ssl_ciphers", _)}
-        if(preferLowMemoryUsage) {object.set("ssl_prefer_low_memory_usage", True)}
-        self.internalJsHosts.push(object)
-    }
-
-    setWildcard(
-        key: Option[Path] = None
-        certificate: Option[Path] = None
-        certificateAuthority: Option[Path] = None
-        passphrase: Option[String] = None
-        dhParameters: Option[Path] = None
-        ciphers: Option[String] = None
-        preferLowMemoryUsage: Bool = False
-    ) {
-        let object = self.intenalSystem.js().object()
-        key.each {object.set("key_file_name", _.absolute())}
-        certificate.each {object.set("cert_file_name", _.absolute())}
-        certificateAuthority.each {object.set("ca_file_name", _.absolute())}
-        passphrase.each {object.set("passphrase", _)}
-        dhParameters.each {object.set("dh_params_file_name", _.absolute())}
-        ciphers.each {object.set("ssl_ciphers", _)}
-        if(preferLowMemoryUsage) {object.set("ssl_prefer_low_memory_usage", True)}
-        self.internalJsWildcard = object
-    }
-    
-    listen(handler: WebRequest[WebResponse] => Unit) {
-        let uws = Js.import("uWebSockets.js")
-        Js.awaitCancellablePromise {resolveServer, rejectServer, onSettleServer =>
-            self.internalJsApp = if(!self.internalJsWildcard.isNullOrUndefined()) {
-                uws->SSLApp(self.internalJsWildcard)
-            } elseIf {self.internalJsHosts.any {h => h->"key_file_name".truthy()}} {
-                uws->SSLApp()
-            } else {
-                uws->App()
-            }
-            self.internalJsHosts.each {h => 
-                self.internalJsApp->addServerName(h->hostname, h)
-            }
-            let handleRequest = Js->{res, req, context => 
-                mutable abortedByUws = False
-                let method = req->getMethod()?
-                let path = req->getUrl()?
-                let query = req->getQuery().coalesce("")?
-                let headers = StringMap.new()
-                req->forEach(Js->{key, value => headers.set(key?, value?)})
-                let chunks = Array.new()
-                let task = Js.currentTask().spawn {task => 
-                    try {
-                        task.throwIfAborted()
-                        let webRequest = WebRequest(
-                            internalJsApp = self.internalJsApp
-                            internalJsContext = context
-                            internalMethod = method
-                            internalPath = path
-                            internalQuery = query
-                            internalHeaders = headers
-                            internalJsResponse = res
-                            internalResponse = None
-                            internalResponseHeaders = StringMap.new()
-                            internalResponseChunks = Array.new()
-                            internalResponseStatus = "200 OK"
-                            internalCloseConnection = False
-                            internalResolveFlush = Js.null()
-                            internalContentSize = -1
-                            internalResponded = False
-                        );
-                        handler(webRequest)
-                        task.throwIfAborted()
-                        if(context.nullish() && !webRequest.internalResponded && webRequest.internalContentSize >= 0) {
-                            webRequest.flush()
-                            task.throwIfAborted()
-                        }
-                        if(context.nullish() && !webRequest.internalResponded) {
-                            Js.awaitCancellablePromise {resolve, reject, onSettle => 
-                                res->cork(Js->{
-                                    try {
-                                        // Js.throwIfCancelled() <- TODO ignored in sync context
-                                        if(webRequest.internalResolveFlush.falsy()) {
-                                            res->writeStatus(webRequest.internalResponseStatus)
-                                            webRequest.internalResponseHeaders.each {key, value => 
-                                                res->writeHeader(key, value)
-                                            }
-                                        }
-                                        let chunk = internalChunksToChunk(webRequest.internalResponseChunks)
-                                        res->end(chunk, webRequest.internalCloseConnection)
-                                        resolve(Unit)
-                                    } catchAny {e =>
-                                        reject(e)
-                                    }
-                                })
-                            }
-                        }
-                    } catchAny {e =>
-                        if(!abortedByUws) {Js->console->error(e)}
-                        if(!abortedByUws && context.nullish()) {
-                            res->cork(Js->{
-                                if(!abortedByUws) {res->writeStatus("500 Internal Server Error")}
-                                if(!abortedByUws) {res->end()}
-                            })
-                        }
-                    }
-                }
-                res->onAborted(Js->{
-                    abortedByUws = True
-                    task.abort()
-                })
-            }
-            self.internalJsApp->any("/*", handleRequest)
-            if(!self.internalJsWebSockets.nullish()) {
-                self.internalJsApp->ws("/*", self.internalJsWebSockets
-                    .with("upgrade", handleRequest)
-                    .with("open", Js->{ws => ws->getUserData()->onOpen(ws)})
-                    .with("message", Js->{ws, m, b => ws->getUserData()->onMessage(m, b)})
-                    .with("close", Js->{ws => ws->getUserData()->onClose()})
-                )
-            }
-            self.internalJsApp->listen(self.internalHost, self.internalPort, Js->{listenSocket =>
-                if(!listenSocket.nullish()) {
-                    mutable abort = Js->{}
-                    abort = Js->{
-                        Js.currentTask().controller->signal->removeEventListener("abort", abort)
-                        uws->"us_listen_socket_close"(listenSocket)
-                        self.internalJsApp->close()
-                    }
-                    Js.currentTask().controller->signal->addEventListener("abort", abort)
-                } else {
-                    rejectServer(Js->Error->("listenSocket was nullish")?)
-                }
-                Unit
-            })
-        }
-    }
-
-    publishBuffer(topic: String, message: Buffer) { // Should this be corked?
-        if(!self.internalJsApp.nullish()) {
-            self.internalJsApp->publish(topic, message!->buffer, True)
-        }
-    }
-    
-    publishText(topic: String, message: String) { // Should this be corked?
-        if(!self.internalJsApp.nullish()) {
-            self.internalJsApp->publish(topic, message, False)
-        }
-    }
-}
-
-extend self[T]: WebRequest[T] {
-
-    readMethod(): String {
-        self.internalMethod
-    }
-
-    readPath(): String {
-        self.internalPath
-    }
-
-    readRawQueryString(): String {
-        self.internalQuery
-    }
-
-    readQuery(name: String): Option[String] {
-        if(self.internalQuery.size() == 0) {None} else:
-        let ps = self.internalQuery.split('&')
-        let n = name + "="
-        ps.find {p => p == name || p.startsWith(n)}.map {r => 
-            Js->decodeURIComponent(r.dropFirst(n.size()))?
-        }
-    }
-    
-    readHeader(lowerCaseName: String): Option[String] {
-        self.internalHeaders.get(lowerCaseName)
-    }
-    
-    eachHeader(body: (String, String) => Unit) {
-        self.internalHeaders.each {body(_, _)}
-    }
-    
-}
-
-extend self[T]: WebRequest[T] {
-    
-    writeStatus(codeAndMessage: String) {
-        self.internalResponseStatus = codeAndMessage
-    }
-    
-    writeHeader(name: String, value: String) {
-        self.internalResponseHeaders.set(name, value)
-    }
-    
-    writeContentSize(contentSize: Int) {
-        if(contentSize >= 0) {
-            self.internalContentSize = contentSize
-        }
-    }
-
-    writeText(data: String) {
-        self.internalResponseChunks.push(data!)
-    }
-
-    writeLine(data: String) {
-        self.writeText(data + "\n")
-    }
-
-    writeBuffer(data: Buffer) {
-        self.internalResponseChunks.push(data!)
-    }
-    
-    writeStream(data: Stream[Buffer]) {
-        data.each {self.writeBuffer(_)}
-    }
-
-}
-
-extend self[T]: WebRequest[T] {
-
-    publishBuffer(topic: String, message: Buffer) { // Should this be corked?
-        self.internalJsApp->publish(topic, message!->buffer, True)
-    }
-    
-    publishText(topic: String, message: String) { // Should this be corked?
-        self.internalJsApp->publish(topic, message, False)
-    }
-
-}
-
-extend self[T]: WebRequest[T] {
-    
-    closeConnection() {
-        self.internalCloseConnection = True
-    }
-    
-    readRemoteAddress(): String {
-        Js->TextDecoder->()->decode(self.internalJsResponse->getRemoteAddressAsText())?
-    }
-
-    readProxiedRemoteAddress(): String {
-        Js->TextDecoder->()->decode(self.internalJsResponse->getProxiedRemoteAddressAsText())?
-    }
-
-}
-
-extend self: WebRequest[WebResponse] {
-
-    flush() {
-        if(self.internalResolveFlush.nullish()) {
-            self.internalResolveFlush = Js->{}
-            self.internalJsResponse->cork(Js->{
-                self.internalJsResponse->writeStatus(self.internalResponseStatus)
-                self.internalResponseHeaders.each {key, value =>
-                    self.internalJsResponse->writeHeader(key, value)
-                }
-                self.internalJsResponse->onWritable(Js->{
-                    self.internalResolveFlush.callValue0()
-                    True
-                })
-            })
-        }
-        while {!self.internalResponseChunks.isEmpty()} {
-            Js.awaitCancellablePromise {resolve, reject, onSettle =>
-                self.internalJsResponse->cork(Js->{
-                    mutable backpressure = False
-                    mutable i = 0
-                    while {i < self.internalResponseChunks.size() && !backpressure} {
-                        let rawChunk = self.internalResponseChunks.grab(i)
-                        let chunk = if(rawChunk.typeof() != "string") {
-                            Js->Uint8Array->(rawChunk!->buffer, rawChunk!->byteOffset, rawChunk!->byteLength)
-                        } else {
-                            Js->TextEncoder->()->encode(rawChunk)
-                        }
-                        if(self.internalContentSize >= 0) {
-                            let lastOffset = self.internalJsResponse->getWriteOffset()?
-                            let pair = self.internalJsResponse->tryEnd(chunk, self.internalContentSize)
-                            let ok = pair.get(0)
-                            let responded = pair.get(1)
-                            if(!ok?) {
-                                let written = self.internalJsResponse->getWriteOffset() - lastOffset
-                                backpressure = True
-                                self.internalResponseChunks.set(i, Js->Uint8Array->(chunk->buffer, chunk->byteOffset + written, chunk->byteLength - written))
-                                i -= 1
-                            }
-                        } else {
-                            backpressure = !self.internalJsResponse->write(chunk)?
-                        }
-                        i += 1
-                    }
-                    if(i > 0) {
-                        self.internalResponseChunks.delete(0, i)
-                    }
-                    if(!backpressure) {
-                        resolve(Unit)
-                    } else {
-                        self.internalResolveFlush = Js->{resolve(Unit)}
-                    }
-                })
-            }
-        }
-    }
-
-    flushText(data: String) {
-        self.writeText(data)
-        self.flush()
-    }
-
-    flushBuffer(data: Buffer) {
-        self.writeBuffer(data)
-        self.flush()
-    }
-
-    flushStream(data: Stream[Buffer]) {
-        data.each {self.flushBuffer(_)}
-    }
-
-}
-
-extend self: WebRequest[WebResponse] {
-    
-    readText(encoding: String = "utf8"): String {
-        self.readStream(1073741823).toString(encoding)
-    }
-    
-    readBuffer(): Buffer {
-        self.readStream(1073741823).toBuffer()
-    }
-   
-    readStream(maxPendingBytes: Int = 65536): Stream[Buffer] {
-        let queue = Queue.new[Buffer]()
-        mutable pendingBytes = 0
-        mutable closed = False
-        mutable callResolve = {_ => }
-        self.internalJsResponse->onData(Js->{chunk, isLast =>
-            if(closed) {} else:
-            mutable newChunk = chunk
-            if(isLast.truthy()) {
-                closed = True
-            } else {
-                newChunk = chunk->slice()
-            }
-            pendingBytes += newChunk->byteLength?
-            queue.push(Js->DataView->(newChunk)?)
-            if(pendingBytes >= maxPendingBytes) {self.internalJsResponse->pause()}
-            callResolve(Unit)
-        })
-        Stream {
-            mutable result = None
-            doWhile {
-                Js.throwIfCancelled()
-                if(!queue.isEmpty()) {
-                    let chunk = queue.pop().grab()
-                    let paused = pendingBytes >= maxPendingBytes
-                    pendingBytes -= chunk.size()
-                    if(!closed && paused && pendingBytes < maxPendingBytes) {
-                        self.internalJsResponse->unpause()
-                    }
-                    result = Some(chunk)
-                    False
-                } elseIf {closed} {
-                    False
-                } else {
-                    Js.awaitCancellablePromise {resolve, reject, onSettle =>
-                        callResolve = resolve
-                    }
-                    True
-                }
-            }
-            result
-        } {
-            closed = True
-            callResolve(Unit)
-        }
-    }
-    
-}
-
-extend self[T]: WebRequest[T] {
-    
-    needsWebSocket(): Bool {
-        !self.internalJsContext.nullish()
-    }
-    
-}
-
-extend self: WebRequest[WebResponse] {
-    
-    openWebSocket(): WebSocketConnection {
-        let connection = WebSocketConnection(
-            messages = Queue.new()
-            listeners = Queue.new()
-            webSocket = Js.null()
-        )
-        Js.awaitCancellablePromise {resolve, reject, onSettle => 
-            let userData = Js->(
-                onOpen = Js->{webSocket =>
-                    connection.webSocket = webSocket
-                    resolve(connection)
-                }
-                onClose = Js->{
-                    connection.webSocket = Js.null()
-                    reject(Js->Error->("WebSocket closed")?)
-                    connection.listeners.each {_, listener => listener(Unit)}
-                    connection.listeners.clear()
-                }
-                onMessage = Js->{message, isBinary =>
-                    connection.messages.push(if(isBinary.truthy()) {
-                        Js->DataView->(message)
-                    } else {
-                        Js->TextDecoder->()->decode(message)
-                    })
-                    connection.listeners.each {_, listener => listener(Unit)}
-                    connection.listeners.clear()
-                }
-            )
-            self.internalJsResponse->cork(Js->{
-                self.internalJsResponse->upgrade(
-                    userData
-                    self.internalHeaders.grab("sec-websocket-key")
-                    self.internalHeaders.grab("sec-websocket-protocol")
-                    self.internalHeaders.grab("sec-websocket-extensions")
-                    self.internalJsContext
-                )
-            })
-        }
-    }
-
-}
-
-extend self: WebSocketConnection {
-    
-    readText(encoding: String = "utf8"): Option[String] {
-        self.readAny {_} {_.toString(encoding)}
-    }
-
-    readBuffer(): Option[Buffer] {
-        self.readAny {_.toBuffer()} {_}
-    }
-    
-    readAny[T](fromText: String => T, fromBuffer: Buffer => T): Option[T] {
-        Js.throwIfCancelled()
-        while {self.messages.isEmpty() && !self.webSocket.nullish()} {
-            Js.awaitCancellablePromise {resolve, reject, onSettle =>
-                let key = self.listeners.push(resolve)
-                onSettle {_ => self.listeners.remove(key)}
-            }
-        }
-        if(self.webSocket.nullish()) {None} else:
-        let data = self.messages.pop().grab()
-        if(data.typeof() == "string") {
-            Some(fromText(data?))
-        } else {
-            Some(fromBuffer(data?))
-        }
-    }
-
-    readStream(): Stream[Buffer] {
-        Stream {self.readBuffer()} {self.close()}
-    }
-    
-    writeBuffer(message: Buffer) {
-        internalSend(self) {self.webSocket->send(message!->buffer, True) !== 2}
-    }
-    
-    writeText(message: String) {
-        internalSend(self) {self.webSocket->send(message!, True) !== 2}
-    }
-    
-    publishBuffer(topic: String, message: Buffer) {
-        internalSend(self) {self.webSocket->publish(topic, message!->buffer, True).truthy()}
-    }
-    
-    publishText(topic: String, message: String) {
-        internalSend(self) {self.webSocket->publish(topic, message!, True).truthy()}
-    }
-
-    subscribe(topic: String) {
-        if(self.webSocket.nullish()) {Js.throw(Js->Error->("WebSocket is closed"))}
-        self.webSocket->subscribe(topic)
-    }
-
-    unsubscribe(topic: String) {
-        if(self.webSocket.nullish()) {Js.throw(Js->Error->("WebSocket is closed"))}
-        self.webSocket->unsubscribe(topic)
-    }
-
-    isSubscribedTo(topic: String): Bool {
-        if(self.webSocket.nullish()) {Js.throw(Js->Error->("WebSocket is closed"))}
-        self.webSocket->isSubscribed(topic)?
-    }
-        
-    subscriptions(): List[String] {
-        if(self.webSocket.nullish()) {Js.throw(Js->Error->("WebSocket is closed"))}
-        self.webSocket->getTopics()?
-    }
-
-    close(): Unit {
-        if(!self.webSocket.nullish()) {
-            self.webSocket->close()
-            self.webSocket = Js.null()
-        }
-    }
-
-}
-
-internalSend[T](self: WebSocketConnection, send: () => Bool) {
-    Js.awaitCancellablePromise {resolve, reject, onSettle =>
-        if(self.webSocket.nullish()) {reject(Js->Error->("WebSocket is closed")?)} else:
-        self.webSocket->cork(Js->{
-            if(self.webSocket.nullish()) {reject(Js->Error->("WebSocket is closed")?)} else:
-            if(!send()) {reject(Js->Error->("Dropped message due to backpressure")?)} else:
-            resolve(Unit)
-        })
-    }
-}
-
-internalChunksToChunk(chunks: Array[JsValue]): JsValue {
-    if(chunks.size() == 0) {Js.undefined()} else:
-    let firstChunk = chunks.grabFirst()
-    let firstIsString = firstChunk.typeof() == "string"
-    if(firstIsString && chunks.size() == 1) {firstChunk} else:
-    if(firstIsString && chunks.all {c => c.typeof() == "string"}) {
-        let strings: Array[String] = chunks!?
-        strings.join()!
-    } else:
-    
-    mutable totalLength = 0
-    chunks.eachWithIndex {i, chunk => 
-        if(chunk.typeof() == "string") {
-            let uint8Array = Js->TextEncoder->()->encode(chunk)
-            chunks!->array.set(i, uint8Array)
-            totalLength += uint8Array->byteLength?
-        } else {
-            totalLength += chunk->byteLength?
-        }
-    }
-    
-    let result = Js->Uint8Array->(totalLength)
-    mutable offset = 0
-    chunks.each {chunk => 
-        let uint8Array = Js->Uint8Array->(chunk->buffer, chunk->byteOffset, chunk->byteLength)
-        result->set(uint8Array, offset);
-        offset += chunk->byteLength?
-    }
-    result
-}
-
-parseMultipartFields(data: Buffer, contentType: String): Option[Array[MultipartField]] {
-    let uws = Js.import("uWebSockets.js")
-    let parts = uws->getParts(data, contentType)
-    if(!parts.nullish()) {parts?}
-}
-
-extend self: MultipartField {
-    
-    data(): Buffer {
-        Js->DataView->(self!->data)?
-    }
-
-    name(): String {
-        self!->name?
-    }
-
-    type(): Option[String] {
-        if(!self!->type.nullish()) {self!->type?}
-    }
-
-    filename(): Option[String] {
-        if(!self!->filename.nullish()) {self!->filename?}
-    }
-
-}
+capability WebServer(
+    intenalSystem: NodeSystem
+    internalHost: String
+    internalPort: Int
+    mutable internalJsWebSockets: JsValue
+    mutable internalJsWildcard: JsValue
+    mutable internalJsHosts: Array[JsValue]
+    mutable internalJsApp: JsValue
+)
+
+class WebRequest[T](
+    internalJsApp: JsValue
+    internalJsContext: JsValue
+    internalMethod: String
+    internalPath: String
+    internalQuery: String
+    internalHeaders: StringMap[String]
+    internalJsResponse: JsValue
+    internalResponse: Option[T]
+    internalResponseHeaders: StringMap[String]
+    internalResponseChunks: Array[JsValue]
+    mutable internalResponseStatus: String
+    mutable internalCloseConnection: Bool
+    mutable internalResolveFlush: JsValue
+    mutable internalContentSize: Int
+    mutable internalResponded: Bool
+)
+
+capability WebResponse {}
+
+data MultipartField {}
+
+capability WebSocketConnection(
+    messages: Queue[JsValue]
+    listeners: Queue[Unit => Unit]
+    mutable webSocket: JsValue
+)
+
+new(
+    system: NodeSystem
+    host: String
+    port: Int
+): WebServer {
+    WebServer(system, host, port, system.js().null(), system.js().null(), [].toArray(), system.js().null())
+}
+
+extend self: WebServer {
+    
+    enableWebSockets(
+        maxPayloadBytes: Int = 16384
+        maxBackpressureBytes: Int = 65536
+        closeDueToMaxBackpressureBytes: Bool = False
+        maxLifetime: Option[Duration] = None
+        idleTimeout: Option[Duration] = None
+    ) {
+        self.internalJsWebSockets = self.intenalSystem.js().object()
+        self.internalJsWebSockets.set("maxPayloadLength", maxPayloadBytes)
+        self.internalJsWebSockets.set("maxBackpressureBytes", maxBackpressureBytes)
+        self.internalJsWebSockets.set("closeOnBackpressureLimit", closeDueToMaxBackpressureBytes)
+        maxLifetime.each {self.internalJsWebSockets.set("maxLifetime", (_.seconds / 60).round().toInt())}
+        idleTimeout.each {self.internalJsWebSockets.set("idleTimeout", _.seconds.round().toInt())}
+    }
+    
+    addHost(
+        hostname: String
+        key: Option[Path] = None
+        certificate: Option[Path] = None
+        certificateAuthority: Option[Path] = None
+        passphrase: Option[String] = None
+        dhParameters: Option[Path] = None
+        ciphers: Option[String] = None
+        preferLowMemoryUsage: Bool = False
+    ) {
+        let object = self.intenalSystem.js().object().with("hostname", hostname)
+        key.each {object.set("key_file_name", _.absolute())}
+        certificate.each {object.set("cert_file_name", _.absolute())}
+        certificateAuthority.each {object.set("ca_file_name", _.absolute())}
+        passphrase.each {object.set("passphrase", _)}
+        dhParameters.each {object.set("dh_params_file_name", _.absolute())}
+        ciphers.each {object.set("ssl_ciphers", _)}
+        if(preferLowMemoryUsage) {object.set("ssl_prefer_low_memory_usage", True)}
+        self.internalJsHosts.push(object)
+    }
+
+    setWildcard(
+        key: Option[Path] = None
+        certificate: Option[Path] = None
+        certificateAuthority: Option[Path] = None
+        passphrase: Option[String] = None
+        dhParameters: Option[Path] = None
+        ciphers: Option[String] = None
+        preferLowMemoryUsage: Bool = False
+    ) {
+        let object = self.intenalSystem.js().object()
+        key.each {object.set("key_file_name", _.absolute())}
+        certificate.each {object.set("cert_file_name", _.absolute())}
+        certificateAuthority.each {object.set("ca_file_name", _.absolute())}
+        passphrase.each {object.set("passphrase", _)}
+        dhParameters.each {object.set("dh_params_file_name", _.absolute())}
+        ciphers.each {object.set("ssl_ciphers", _)}
+        if(preferLowMemoryUsage) {object.set("ssl_prefer_low_memory_usage", True)}
+        self.internalJsWildcard = object
+    }
+    
+    listen(handler: WebRequest[WebResponse] => Unit) {
+        let uws = Js.import("uWebSockets.js")
+        Js.awaitCancellablePromise {resolveServer, rejectServer, onSettleServer =>
+            self.internalJsApp = if(!self.internalJsWildcard.isNullOrUndefined()) {
+                uws->SSLApp(self.internalJsWildcard)
+            } elseIf {self.internalJsHosts.any {h => h->"key_file_name".truthy()}} {
+                uws->SSLApp()
+            } else {
+                uws->App()
+            }
+            self.internalJsHosts.each {h => 
+                self.internalJsApp->addServerName(h->hostname, h)
+            }
+            let handleRequest = Js->{res, req, context => 
+                mutable abortedByUws = False
+                let method = req->getMethod()?
+                let path = req->getUrl()?
+                let query = req->getQuery().coalesce("")?
+                let headers = StringMap.new()
+                req->forEach(Js->{key, value => headers.set(key?, value?)})
+                let chunks = Array.new()
+                let task = Js.currentTask().spawn {task => 
+                    try {
+                        task.throwIfAborted()
+                        let webRequest = WebRequest(
+                            internalJsApp = self.internalJsApp
+                            internalJsContext = context
+                            internalMethod = method
+                            internalPath = path
+                            internalQuery = query
+                            internalHeaders = headers
+                            internalJsResponse = res
+                            internalResponse = None
+                            internalResponseHeaders = StringMap.new()
+                            internalResponseChunks = Array.new()
+                            internalResponseStatus = "200 OK"
+                            internalCloseConnection = False
+                            internalResolveFlush = Js.null()
+                            internalContentSize = -1
+                            internalResponded = False
+                        );
+                        handler(webRequest)
+                        task.throwIfAborted()
+                        if(context.nullish() && !webRequest.internalResponded && webRequest.internalContentSize >= 0) {
+                            webRequest.flush()
+                            task.throwIfAborted()
+                        }
+                        if(context.nullish() && !webRequest.internalResponded) {
+                            Js.awaitCancellablePromise {resolve, reject, onSettle => 
+                                res->cork(Js->{
+                                    try {
+                                        // Js.throwIfCancelled() <- TODO ignored in sync context
+                                        if(webRequest.internalResolveFlush.falsy()) {
+                                            res->writeStatus(webRequest.internalResponseStatus)
+                                            webRequest.internalResponseHeaders.each {key, value => 
+                                                res->writeHeader(key, value)
+                                            }
+                                        }
+                                        let chunk = internalChunksToChunk(webRequest.internalResponseChunks)
+                                        res->end(chunk, webRequest.internalCloseConnection)
+                                        resolve(Unit)
+                                    } catchAny {e =>
+                                        reject(e)
+                                    }
+                                })
+                            }
+                        }
+                    } catchAny {e =>
+                        if(!abortedByUws) {Js->console->error(e)}
+                        if(!abortedByUws && context.nullish()) {
+                            res->cork(Js->{
+                                if(!abortedByUws) {res->writeStatus("500 Internal Server Error")}
+                                if(!abortedByUws) {res->end()}
+                            })
+                        }
+                    }
+                }
+                res->onAborted(Js->{
+                    abortedByUws = True
+                    task.abort()
+                })
+            }
+            self.internalJsApp->any("/*", handleRequest)
+            if(!self.internalJsWebSockets.nullish()) {
+                self.internalJsApp->ws("/*", self.internalJsWebSockets
+                    .with("upgrade", handleRequest)
+                    .with("open", Js->{ws => ws->getUserData()->onOpen(ws)})
+                    .with("message", Js->{ws, m, b => ws->getUserData()->onMessage(m, b)})
+                    .with("close", Js->{ws => ws->getUserData()->onClose()})
+                )
+            }
+            self.internalJsApp->listen(self.internalHost, self.internalPort, Js->{listenSocket =>
+                if(!listenSocket.nullish()) {
+                    mutable abort = Js->{}
+                    abort = Js->{
+                        Js.currentTask().controller->signal->removeEventListener("abort", abort)
+                        uws->"us_listen_socket_close"(listenSocket)
+                        self.internalJsApp->close()
+                    }
+                    Js.currentTask().controller->signal->addEventListener("abort", abort)
+                } else {
+                    rejectServer(Js->Error->("listenSocket was nullish")?)
+                }
+                Unit
+            })
+        }
+    }
+
+    publishBuffer(topic: String, message: Buffer) { // Should this be corked?
+        if(!self.internalJsApp.nullish()) {
+            self.internalJsApp->publish(topic, message!->buffer, True)
+        }
+    }
+    
+    publishText(topic: String, message: String) { // Should this be corked?
+        if(!self.internalJsApp.nullish()) {
+            self.internalJsApp->publish(topic, message, False)
+        }
+    }
+}
+
+extend self[T]: WebRequest[T] {
+
+    readMethod(): String {
+        self.internalMethod
+    }
+
+    readPath(): String {
+        self.internalPath
+    }
+
+    readRawQueryString(): String {
+        self.internalQuery
+    }
+
+    readQuery(name: String): Option[String] {
+        if(self.internalQuery.size() == 0) {None} else:
+        let ps = self.internalQuery.split('&')
+        let n = name + "="
+        ps.find {p => p == name || p.startsWith(n)}.map {r => 
+            Js->decodeURIComponent(r.dropFirst(n.size()))?
+        }
+    }
+    
+    readHeader(lowerCaseName: String): Option[String] {
+        self.internalHeaders.get(lowerCaseName)
+    }
+    
+    eachHeader(body: (String, String) => Unit) {
+        self.internalHeaders.each {body(_, _)}
+    }
+    
+}
+
+extend self[T]: WebRequest[T] {
+    
+    writeStatus(codeAndMessage: String) {
+        self.internalResponseStatus = codeAndMessage
+    }
+    
+    writeHeader(name: String, value: String) {
+        self.internalResponseHeaders.set(name, value)
+    }
+    
+    writeContentSize(contentSize: Int) {
+        if(contentSize >= 0) {
+            self.internalContentSize = contentSize
+        }
+    }
+
+    writeText(data: String) {
+        self.internalResponseChunks.push(data!)
+    }
+
+    writeLine(data: String) {
+        self.writeText(data + "\n")
+    }
+
+    writeBuffer(data: Buffer) {
+        self.internalResponseChunks.push(data!)
+    }
+    
+    writeStream(data: Stream[Buffer]) {
+        data.each {self.writeBuffer(_)}
+    }
+
+}
+
+extend self[T]: WebRequest[T] {
+
+    publishBuffer(topic: String, message: Buffer) { // Should this be corked?
+        self.internalJsApp->publish(topic, message!->buffer, True)
+    }
+    
+    publishText(topic: String, message: String) { // Should this be corked?
+        self.internalJsApp->publish(topic, message, False)
+    }
+
+}
+
+extend self[T]: WebRequest[T] {
+    
+    closeConnection() {
+        self.internalCloseConnection = True
+    }
+    
+    readRemoteAddress(): String {
+        Js->TextDecoder->()->decode(self.internalJsResponse->getRemoteAddressAsText())?
+    }
+
+    readProxiedRemoteAddress(): String {
+        Js->TextDecoder->()->decode(self.internalJsResponse->getProxiedRemoteAddressAsText())?
+    }
+
+}
+
+extend self: WebRequest[WebResponse] {
+
+    flush() {
+        if(self.internalResolveFlush.nullish()) {
+            self.internalResolveFlush = Js->{}
+            self.internalJsResponse->cork(Js->{
+                self.internalJsResponse->writeStatus(self.internalResponseStatus)
+                self.internalResponseHeaders.each {key, value =>
+                    self.internalJsResponse->writeHeader(key, value)
+                }
+                self.internalJsResponse->onWritable(Js->{
+                    self.internalResolveFlush.callValue0()
+                    True
+                })
+            })
+        }
+        while {!self.internalResponseChunks.isEmpty()} {
+            Js.awaitCancellablePromise {resolve, reject, onSettle =>
+                self.internalJsResponse->cork(Js->{
+                    mutable backpressure = False
+                    mutable i = 0
+                    while {i < self.internalResponseChunks.size() && !backpressure} {
+                        let rawChunk = self.internalResponseChunks.grab(i)
+                        let chunk = if(rawChunk.typeof() != "string") {
+                            Js->Uint8Array->(rawChunk!->buffer, rawChunk!->byteOffset, rawChunk!->byteLength)
+                        } else {
+                            Js->TextEncoder->()->encode(rawChunk)
+                        }
+                        if(self.internalContentSize >= 0) {
+                            let lastOffset = self.internalJsResponse->getWriteOffset()?
+                            let pair = self.internalJsResponse->tryEnd(chunk, self.internalContentSize)
+                            let ok = pair.get(0)
+                            let responded = pair.get(1)
+                            if(!ok?) {
+                                let written = self.internalJsResponse->getWriteOffset() - lastOffset
+                                backpressure = True
+                                self.internalResponseChunks.set(i, Js->Uint8Array->(chunk->buffer, chunk->byteOffset + written, chunk->byteLength - written))
+                                i -= 1
+                            }
+                        } else {
+                            backpressure = !self.internalJsResponse->write(chunk)?
+                        }
+                        i += 1
+                    }
+                    if(i > 0) {
+                        self.internalResponseChunks.delete(0, i)
+                    }
+                    if(!backpressure) {
+                        resolve(Unit)
+                    } else {
+                        self.internalResolveFlush = Js->{resolve(Unit)}
+                    }
+                })
+            }
+        }
+    }
+
+    flushText(data: String) {
+        self.writeText(data)
+        self.flush()
+    }
+
+    flushBuffer(data: Buffer) {
+        self.writeBuffer(data)
+        self.flush()
+    }
+
+    flushStream(data: Stream[Buffer]) {
+        data.each {self.flushBuffer(_)}
+    }
+
+}
+
+extend self: WebRequest[WebResponse] {
+    
+    readText(encoding: String = "utf8"): String {
+        self.readStream(1073741823).toString(encoding)
+    }
+    
+    readBuffer(): Buffer {
+        self.readStream(1073741823).toBuffer()
+    }
+   
+    readStream(maxPendingBytes: Int = 65536): Stream[Buffer] {
+        let queue = Queue.new[Buffer]()
+        mutable pendingBytes = 0
+        mutable closed = False
+        mutable callResolve = {_ => }
+        self.internalJsResponse->onData(Js->{chunk, isLast =>
+            if(closed) {} else:
+            mutable newChunk = chunk
+            if(isLast.truthy()) {
+                closed = True
+            } else {
+                newChunk = chunk->slice()
+            }
+            pendingBytes += newChunk->byteLength?
+            queue.push(Js->DataView->(newChunk)?)
+            if(pendingBytes >= maxPendingBytes) {self.internalJsResponse->pause()}
+            callResolve(Unit)
+        })
+        Stream {
+            mutable result = None
+            doWhile {
+                Js.throwIfCancelled()
+                if(!queue.isEmpty()) {
+                    let chunk = queue.pop().grab()
+                    let paused = pendingBytes >= maxPendingBytes
+                    pendingBytes -= chunk.size()
+                    if(!closed && paused && pendingBytes < maxPendingBytes) {
+                        self.internalJsResponse->unpause()
+                    }
+                    result = Some(chunk)
+                    False
+                } elseIf {closed} {
+                    False
+                } else {
+                    Js.awaitCancellablePromise {resolve, reject, onSettle =>
+                        callResolve = resolve
+                    }
+                    True
+                }
+            }
+            result
+        } {
+            closed = True
+            callResolve(Unit)
+        }
+    }
+    
+}
+
+extend self[T]: WebRequest[T] {
+    
+    needsWebSocket(): Bool {
+        !self.internalJsContext.nullish()
+    }
+    
+}
+
+extend self: WebRequest[WebResponse] {
+    
+    openWebSocket(): WebSocketConnection {
+        let connection = WebSocketConnection(
+            messages = Queue.new()
+            listeners = Queue.new()
+            webSocket = Js.null()
+        )
+        Js.awaitCancellablePromise {resolve, reject, onSettle => 
+            let userData = Js->(
+                onOpen = Js->{webSocket =>
+                    connection.webSocket = webSocket
+                    resolve(connection)
+                }
+                onClose = Js->{
+                    connection.webSocket = Js.null()
+                    reject(Js->Error->("WebSocket closed")?)
+                    connection.listeners.each {_, listener => listener(Unit)}
+                    connection.listeners.clear()
+                }
+                onMessage = Js->{message, isBinary =>
+                    connection.messages.push(if(isBinary.truthy()) {
+                        Js->DataView->(message)
+                    } else {
+                        Js->TextDecoder->()->decode(message)
+                    })
+                    connection.listeners.each {_, listener => listener(Unit)}
+                    connection.listeners.clear()
+                }
+            )
+            self.internalJsResponse->cork(Js->{
+                self.internalJsResponse->upgrade(
+                    userData
+                    self.internalHeaders.grab("sec-websocket-key")
+                    self.internalHeaders.grab("sec-websocket-protocol")
+                    self.internalHeaders.grab("sec-websocket-extensions")
+                    self.internalJsContext
+                )
+            })
+        }
+    }
+
+}
+
+extend self: WebSocketConnection {
+    
+    readText(encoding: String = "utf8"): Option[String] {
+        self.readAny {_} {_.toString(encoding)}
+    }
+
+    readBuffer(): Option[Buffer] {
+        self.readAny {_.toBuffer()} {_}
+    }
+    
+    readAny[T](fromText: String => T, fromBuffer: Buffer => T): Option[T] {
+        Js.throwIfCancelled()
+        while {self.messages.isEmpty() && !self.webSocket.nullish()} {
+            Js.awaitCancellablePromise {resolve, reject, onSettle =>
+                let key = self.listeners.push(resolve)
+                onSettle {_ => self.listeners.remove(key)}
+            }
+        }
+        if(self.webSocket.nullish()) {None} else:
+        let data = self.messages.pop().grab()
+        if(data.typeof() == "string") {
+            Some(fromText(data?))
+        } else {
+            Some(fromBuffer(data?))
+        }
+    }
+
+    readStream(): Stream[Buffer] {
+        Stream {self.readBuffer()} {self.close()}
+    }
+    
+    writeBuffer(message: Buffer) {
+        internalSend(self) {self.webSocket->send(message!->buffer, True) !== 2}
+    }
+    
+    writeText(message: String) {
+        internalSend(self) {self.webSocket->send(message!, True) !== 2}
+    }
+    
+    publishBuffer(topic: String, message: Buffer) {
+        internalSend(self) {self.webSocket->publish(topic, message!->buffer, True).truthy()}
+    }
+    
+    publishText(topic: String, message: String) {
+        internalSend(self) {self.webSocket->publish(topic, message!, True).truthy()}
+    }
+
+    subscribe(topic: String) {
+        if(self.webSocket.nullish()) {Js.throw(Js->Error->("WebSocket is closed"))}
+        self.webSocket->subscribe(topic)
+    }
+
+    unsubscribe(topic: String) {
+        if(self.webSocket.nullish()) {Js.throw(Js->Error->("WebSocket is closed"))}
+        self.webSocket->unsubscribe(topic)
+    }
+
+    isSubscribedTo(topic: String): Bool {
+        if(self.webSocket.nullish()) {Js.throw(Js->Error->("WebSocket is closed"))}
+        self.webSocket->isSubscribed(topic)?
+    }
+        
+    subscriptions(): List[String] {
+        if(self.webSocket.nullish()) {Js.throw(Js->Error->("WebSocket is closed"))}
+        self.webSocket->getTopics()?
+    }
+
+    close(): Unit {
+        if(!self.webSocket.nullish()) {
+            self.webSocket->close()
+            self.webSocket = Js.null()
+        }
+    }
+
+}
+
+internalSend[T](self: WebSocketConnection, send: () => Bool) {
+    Js.awaitCancellablePromise {resolve, reject, onSettle =>
+        if(self.webSocket.nullish()) {reject(Js->Error->("WebSocket is closed")?)} else:
+        self.webSocket->cork(Js->{
+            if(self.webSocket.nullish()) {reject(Js->Error->("WebSocket is closed")?)} else:
+            if(!send()) {reject(Js->Error->("Dropped message due to backpressure")?)} else:
+            resolve(Unit)
+        })
+    }
+}
+
+internalChunksToChunk(chunks: Array[JsValue]): JsValue {
+    if(chunks.size() == 0) {Js.undefined()} else:
+    let firstChunk = chunks.grabFirst()
+    let firstIsString = firstChunk.typeof() == "string"
+    if(firstIsString && chunks.size() == 1) {firstChunk} else:
+    if(firstIsString && chunks.all {c => c.typeof() == "string"}) {
+        let strings: Array[String] = chunks!?
+        strings.join()!
+    } else:
+    
+    mutable totalLength = 0
+    chunks.eachWithIndex {i, chunk => 
+        if(chunk.typeof() == "string") {
+            let uint8Array = Js->TextEncoder->()->encode(chunk)
+            chunks!->array.set(i, uint8Array)
+            totalLength += uint8Array->byteLength?
+        } else {
+            totalLength += chunk->byteLength?
+        }
+    }
+    
+    let result = Js->Uint8Array->(totalLength)
+    mutable offset = 0
+    chunks.each {chunk => 
+        let uint8Array = Js->Uint8Array->(chunk->buffer, chunk->byteOffset, chunk->byteLength)
+        result->set(uint8Array, offset);
+        offset += chunk->byteLength?
+    }
+    result
+}
+
+parseMultipartFields(data: Buffer, contentType: String): Option[Array[MultipartField]] {
+    let uws = Js.import("uWebSockets.js")
+    let parts = uws->getParts(data, contentType)
+    if(!parts.nullish()) {parts?}
+}
+
+extend self: MultipartField {
+    
+    data(): Buffer {
+        Js->DataView->(self!->data)?
+    }
+
+    name(): String {
+        self!->name?
+    }
+
+    type(): Option[String] {
+        if(!self!->type.nullish()) {self!->type?}
+    }
+
+    filename(): Option[String] {
+        if(!self!->filename.nullish()) {self!->filename?}
+    }
+
+}