use Deno.servettp instead of std/http/server.ts

Author: v1rtl

app.ts

@@ -1,4 +1,4 @@
-import { ConnInfo, path, serve, ServeInit } from './deps.ts'
+import { ConnInfo, path, ServeInit } from './deps.ts'
 import { pushMiddleware, Router, UseMethodParams } from './router.ts'
 import { THResponse } from './response.ts'
 import { extendMiddleware } from './extend.ts'
@@ -46,7 +46,7 @@ export class App<
   settings: AppSettings & Record<string, any>
   locals: Record<string, string> = {}
   engines: Record<string, TemplateFunc<RenderOptions>> = {}
-  onError: ServeInit['onError']
+  onError: (err: unknown) => Response | Promise<Response>
   notFound: Handler<Req, Res>
   attach: (req: Req, res: Res, next: NextFunction) => void
 
@@ -67,7 +67,7 @@ export class App<
    */
   render(
     file: string,
-    data: Record<string, any> = {},
+    data: Record<string, unknown> = {},
     cb: (err: unknown, html: unknown) => void,
     options: TemplateEngineOptions<RenderOptions> = {},
   ) {
@@ -190,7 +190,7 @@ export class App<
     }
     mw.push({ type: 'mw', handler: this.notFound, path: '/' })
 
-    let idx = 0, err: unknown | null = null
+    let idx = 0, err
     const next: NextFunction = (error) => {
       if (error) err = error
       return loop()
@@ -203,12 +203,11 @@ export class App<
       ))
 
     await loop()
-
-    if (err) throw err // so that serve catches it
+    if (err) throw err
   }
-  handler = async (_req: Request, connInfo: ConnInfo) => {
+  handler = async (_req: Request, connInfo?: ConnInfo) => {
     const req = _req.clone() as Req
-    req.conn = connInfo
+    req.conn = connInfo!
     const res = {
       _init: {
         headers: new Headers({
@@ -219,7 +218,11 @@ export class App<
       },
       _body: undefined,
     }
-    await this.#prepare(req, res)
+    try {
+      await this.#prepare(req, res)
+    } catch (e) {
+      return this.onError(e)
+    }
     return new Response(res._body, res._init)
   }
   /**
@@ -229,11 +232,17 @@ export class App<
    * @param host server listening host
    */
   async listen(port: number, cb?: () => void, hostname?: string) {
-    await serve(this.handler, {
-      port,
-      onListen: cb,
-      hostname,
-      onError: this.onError,
-    })
+    const listener = Deno.listen({ hostname, port })
+    for await (const conn of listener) {
+      ;(async () => {
+        const requests = Deno.serveHttp(conn)
+        for await (const { request, respondWith } of requests) {
+          const response = await this.handler(request, conn)
+          if (response) {
+            respondWith(response)
+          }
+        }
+      })
+    }
   }
 }

deps.ts

@@ -1,7 +1,6 @@
 export type { ServeInit } from 'https://deno.land/[email protected]/http/server.ts'
 export { parse as parseRange } from 'https://deno.land/x/[email protected]/parse.ts'
 export type { RangesSpecifier } from 'https://deno.land/x/[email protected]/parse.ts'
-export { serve } from 'https://deno.land/[email protected]/http/server.ts'
 export type { ConnInfo } from 'https://deno.land/[email protected]/http/server.ts'
 export { typeByExtension } from 'https://deno.land/[email protected]/media_types/type_by_extension.ts'
 export { getCharset } from 'https://deno.land/[email protected]/media_types/get_charset.ts'

examples/https/mod.ts

@@ -1,10 +1,11 @@
 import { App } from '../../app.ts'
 import { serveTls } from 'https://deno.land/[email protected]/http/server.ts'
-import { THRequest } from '../../request.ts'
 
 const app = new App()
 
-app.get('/', (req, res) => void res.send(`Hello World from ${req.protocol}`))
+app.get('/', (req, res) => {
+  throw new Error(`Hello World from ${req.protocol}`)
+})
 
 await serveTls(app.handler, {
   port: 3000,

mod.ts

@@ -1,4 +1,4 @@
 export * from './app.ts'
-export type { Handler, AppConstructor } from './types.ts'
+export type { AppConstructor, Handler } from './types.ts'
 export type { THRequest } from './request.ts'
-export type { THResponse } from './response.ts'
+export type { THResponse } from './response.ts'

onError.ts

@@ -1,7 +1,6 @@
 import { STATUS_CODES } from './constants.ts'
-import { ServeInit } from './deps.ts'
 
-export const onErrorHandler: ServeInit['onError'] = (err) => {
+export const onErrorHandler = (err: unknown) => {
   if (err instanceof Error) console.error(err)
 
   const error = err as Error & { code?: number; status?: number }

tests/utils.ts

@@ -10,7 +10,7 @@ export const randomPort = async () => await getFreePort(random(2048, 8064))
 export const BindToSuperDeno = <Req extends THRequest, Res extends THResponse>(
   app: App<unknown, Req, Res>,
 ) => {
-  return superdeno(app.listen)
+  return superdeno(app.handler)
 }
 
 export const InitAppAndTest = (