Write the basic working implementation

Author: v1rtl

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "deno.enable": true
+}

README.md

@@ -1,2 +1,29 @@
 # tinyhttp-deno
-Deno port of tinyhttp, 0-legacy, tiny & fast web framework as a replacement of Express 
+
+Deno port of [tinyhttp](https://github.com/talentlessguy/tinyhttp), 0-legacy, tiny & fast web framework as a replacement of Express.
+
+> **WARNING!** This port is very unstable and lacks features. It also doesn't have all of the tinyhttp's original extensions.
+
+## Example
+
+```ts
+import { App } from ''
+
+const app = new App()
+
+app.use('/', (req, next) => {
+  console.log(`${req.method} ${req.url}`)
+
+  next()
+})
+
+app.get('/:name/', (req) => {
+  req.respond({ body: `Hello ${req.params.name}!` })
+})
+
+app.listen(3000, () => console.log(`Started on :3000`))
+```
+
+## Changes
+
+Because Deno doesn't have the same API for HTTP, there's no `res` argument. To send responses use `req.respond` instead.

app.ts

@@ -0,0 +1,188 @@
+// deno-lint-ignore-file
+import { NextFunction, Router, Handler, Middleware, UseMethodParams } from 'https://esm.sh/@tinyhttp/router'
+import { onErrorHandler, ErrorHandler } from './onError.ts'
+import 'https://deno.land/std@0.87.0/node/global.ts'
+import rg from 'https://esm.sh/regexparam'
+import { Request } from './request.ts'
+import { getURLParams } from 'https://cdn.esm.sh/v15/@tinyhttp/url@1.1.2/esnext/url.js'
+import { extendMiddleware } from './extend.ts'
+import { serve, Server } from 'https://deno.land/std@0.87.0/http/server.ts'
+import { parse } from './parseUrl.ts'
+
+const lead = (x: string) => (x.charCodeAt(0) === 47 ? x : '/' + x)
+
+export const applyHandler = <Req>(h: Handler<Req>) => async (req: Req, next: NextFunction) => {
+  try {
+    if (h.constructor.name === 'AsyncFunction') {
+      await h(req, next)
+    } else h(req, next)
+  } catch (e) {
+    next(e)
+  }
+}
+
+/**
+ * tinyhttp App has a few settings for toggling features
+ */
+export type AppSettings = Partial<
+  Record<'networkExtensions' | 'freshnessTesting' | 'bindAppToReqRes' | 'enableReqRoute', boolean> &
+    Record<'subdomainOffset', number> &
+    Record<'xPoweredBy', string | boolean>
+>
+/**
+ * Function that processes the template
+ */
+export type TemplateFunc<O> = (
+  path: string,
+  locals: Record<string, any>,
+  opts: TemplateEngineOptions<O>,
+  cb: (err: Error, html: unknown) => void
+) => void
+
+export type TemplateEngineOptions<O = any> = Partial<{
+  cache: boolean
+  ext: string
+  renderOptions: Partial<O>
+  viewsFolder: string
+  _locals: Record<string, any>
+}>
+
+export class App<RenderOptions = any, Req extends Request = Request> extends Router<App, Req> {
+  middleware: Middleware<Req>[] = []
+  locals: Record<string, string> = {}
+  noMatchHandler: Handler
+  onError: ErrorHandler
+  settings: AppSettings
+  engines: Record<string, TemplateFunc<RenderOptions>> = {}
+  applyExtensions?: (req: Request, next: NextFunction) => void
+
+  constructor(
+    options: Partial<{
+      noMatchHandler: Handler<Req>
+      onError: ErrorHandler
+      settings: AppSettings
+      applyExtensions: (req: Request, next: NextFunction) => void
+    }> = {}
+  ) {
+    super()
+    this.onError = options?.onError || onErrorHandler
+    this.noMatchHandler = options?.noMatchHandler || this.onError.bind(null, { code: 404 })
+    this.settings = options.settings || { xPoweredBy: true }
+    this.applyExtensions = options?.applyExtensions
+  }
+
+  route(path: string): App {
+    const app = new App()
+
+    this.use(path, app)
+
+    return app
+  }
+
+  use(...args: UseMethodParams<Req, any, App>) {
+    const base = args[0]
+
+    const fns: any[] = args.slice(1)
+
+    if (base === '/') {
+      for (const fn of fns) {
+        if (Array.isArray(fn)) {
+          super.use(base, fn)
+        } else {
+          super.use(base, fns)
+        }
+      }
+    } else if (typeof base === 'function' || base instanceof App) {
+      super.use('/', [base, ...fns])
+    } else if (fns.some((fn) => fn instanceof App) && typeof base === 'string') {
+      super.use(
+        base,
+        fns.map((fn: App) => {
+          if (fn instanceof App) {
+            fn.mountpath = typeof base === 'string' ? base : '/'
+            fn.parent = this as any
+          }
+
+          return fn as any
+        })
+      )
+    } else super.use(...args)
+
+    return this // chainable
+  }
+  find(url: string, method: string) {
+    return this.middleware.filter((m) => {
+      if (!m.path) m.path = '/'
+      m.regex = m.type === 'mw' ? rg(m.path, true) : rg(m.path)
+
+      return (m.method ? m.method === method : true) && m.regex.pattern.test(url)
+    })
+  }
+  /**
+   * Extends Req / Res objects, pushes 404 and 500 handlers, dispatches middleware
+   * @param req Req object
+   * @param res Res object
+   */
+  handler(req: Req, next?: NextFunction) {
+    /* Set X-Powered-By header */
+    const { xPoweredBy } = this.settings
+    if (xPoweredBy) req.headers.set('X-Powered-By', typeof xPoweredBy === 'string' ? xPoweredBy : 'tinyhttp')
+
+    const exts = this.applyExtensions || extendMiddleware<RenderOptions>(this as any)
+
+    req.originalUrl = req.url || req.originalUrl
+
+    const { pathname } = parse(req.originalUrl)
+
+    const mw: Middleware[] = [
+      {
+        handler: exts,
+        type: 'mw',
+        path: '/'
+      },
+      ...this.find(pathname, req.method),
+      {
+        handler: this.noMatchHandler,
+        type: 'mw',
+        path: '/'
+      }
+    ]
+
+    const handle = (mw: Middleware) => async (req: Req, next: NextFunction) => {
+      const { path = '/', handler, type, regex = rg('/') } = mw
+
+      req.url = lead(req.url.substring(path.length)) || '/'
+
+      req.path = parse(req.url).pathname
+
+      if (type === 'route') req.params = getURLParams(regex, pathname)
+
+      await applyHandler<Req>((handler as unknown) as Handler<Req>)(req, next)
+    }
+
+    let idx = 0
+
+    next = next || ((err) => (err ? this.onError(err, req) : loop()))
+
+    const loop = () => idx < mw.length && handle(mw[idx++])(req, next as NextFunction)
+
+    loop()
+  }
+
+  /**
+   * Creates HTTP server and dispatches middleware
+   * @param port server listening port
+   * @param Server callback after server starts listening
+   * @param host server listening host
+   */
+  async listen(port: number, cb?: () => void, hostname = '0.0.0.0'): Promise<Server> {
+    const server = serve({ port, hostname })
+
+    cb?.()
+
+    for await (const req of server) {
+      this.handler(req as any)
+    }
+    return server
+  }
+}

example/mod.ts

@@ -0,0 +1,15 @@
+import { App } from '../app.ts'
+
+const app = new App()
+
+app.use('/', (req, next) => {
+  console.log(`${req.method} ${req.url}`)
+
+  next()
+})
+
+app.get('/:name/', (req) => {
+  req.respond({ body: `Hello ${req.params.name}!` })
+})
+
+app.listen(3000, () => console.log(`Started on :3000`))

extend.ts

@@ -0,0 +1,12 @@
+import { NextFunction } from 'https://esm.sh/@tinyhttp/router'
+import { App } from './app.ts'
+import { Request } from './request.ts'
+
+export const extendMiddleware = <RenderOptions = unknown>(app: App) => (req: Request, next: NextFunction) => {
+  const { settings } = app
+
+  if (settings?.bindAppToReqRes) {
+    req.app = app
+  }
+  next()
+}

onError.ts

@@ -0,0 +1,36 @@
+import { ServerRequest } from 'https://deno.land/std@0.87.0/http/server.ts'
+import { NextFunction } from 'https://esm.sh/@tinyhttp/router'
+import { ALL as STATUS_CODES } from 'https://deno.land/x/status@0.1.0/codes.ts'
+import { status } from 'https://deno.land/x/status@0.1.0/status.ts'
+import { Buffer } from 'https://deno.land/std@0.77.0/node/buffer.ts'
+
+export type ServerError = Partial<{
+  code: number
+  status: number
+  message: string
+}>
+
+export type ErrorHandler = (err: ServerError, req: ServerRequest, next?: NextFunction) => void
+
+export const onErrorHandler: ErrorHandler = async (err: ServerError, req: ServerRequest) => {
+  let code = 500
+
+  if (err.code && err.code in STATUS_CODES) code = err.code
+  else if (err.status) code = err.status
+
+  if (typeof err === 'string' || Buffer.isBuffer(err)) {
+    await req.respond({
+      body: err,
+      status: 500
+    })
+  } else if (code in STATUS_CODES) {
+    await req.respond({
+      body: status.message[code],
+      status: 500
+    })
+  } else
+    req.respond({
+      status: 500,
+      body: err.message
+    })
+}

parseUrl.ts

@@ -0,0 +1,15 @@
+import * as qs from 'https://deno.land/std@0.88.0/node/querystring.ts'
+
+export const pathname = (u: string) => {
+  const end = u.indexOf('?')
+
+  return u.slice(0, end === -1 ? u.length : end)
+}
+
+export const parse = (url: string) => {
+  const path = pathname(url)
+
+  const query = qs.parse(url.slice(url.indexOf('?')))
+
+  return { pathname: path, query }
+}

request.ts

@@ -0,0 +1,10 @@
+// deno-lint-ignore-file
+import { ServerRequest } from 'https://deno.land/std@0.87.0/http/server.ts'
+import { App } from './app.ts'
+
+export interface Request extends ServerRequest {
+  path: string
+  originalUrl: string
+  app: App
+  params: Record<string, any>
+}