add res.vary, res.redirect, res.format, req network exts

Author: v1rtl

app.ts

@@ -3,7 +3,7 @@ import { NextFunction, Router, Handler, Middleware, UseMethodParams } from 'http
 import { onErrorHandler, ErrorHandler } from './onError.ts'
 // import { setImmediate } from 'https://deno.land/std@0.88.0/node/timers.ts'
 import rg from 'https://esm.sh/regexparam'
-import { Request } from './request.ts'
+import { Request, getRouteFromApp } from './request.ts'
 import { Response } from './response.ts'
 import { getURLParams, getPathname } from './parseUrl.ts'
 import { extendMiddleware } from './extend.ts'
@@ -230,6 +230,8 @@ export class App<
 
       req.path = getPathname(req.url)
 
+      if (this.settings?.enableReqRoute) req.route = getRouteFromApp(this as any, handler)
+
       if (type === 'route') req.params = getURLParams(regex, pathname)
 
       await applyHandler<Req, Res>((handler as unknown) as Handler<Req, Res>)(req, res, next)

egg.json

@@ -4,7 +4,7 @@
   "entry": "./app.ts",
   "description": "0-legacy, tiny & fast web framework as a replacement of Express",
   "homepage": "https://github.com/talentlessguy/tinyhttp-deno",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "ignore": ["./examples/**/*.ts"],
   "files": ["./**/*.ts", "README.md"],
   "checkFormat": false,

examples/basic/server.ts

@@ -2,7 +2,7 @@ import { App } from '../../app.ts'
 
 const app = new App()
 
-app.get('/:name/', (req, res) => {
+app.get('/', (req, res) => {
   res.send(`Hello on ${req.url} from Deno v${Deno.version.deno} and tinyhttp! 🦕`)
 })
 

extend.ts

@@ -8,7 +8,14 @@ import {
   getAcceptsCharsets,
   getAcceptsEncodings,
   getAcceptsLanguages,
-  getRangeFromHeader
+  getRangeFromHeader,
+  checkIfXMLHttpRequest,
+  reqIs,
+  getHostname,
+  getIP,
+  getIPs,
+  getProtocol,
+  getSubdomains
 } from './extensions/req/mod.ts'
 import {
   send,
@@ -21,7 +28,9 @@ import {
   getResponseHeader,
   append,
   setLinksHeader,
-  setContentType
+  setContentType,
+  formatResponse,
+  setVaryHeader
 } from './extensions/res/mod.ts'
 
 import { Response, renderTemplate } from './response.ts'
@@ -32,7 +41,7 @@ export const extendMiddleware = <
   Res extends Response = Response
 >(
   app: App
-) => (req: Req, res: Res, next?: NextFunction) => {
+) => (req: Req, res: Res, next: NextFunction) => {
   const { settings } = app
 
   // Request extensions
@@ -54,6 +63,20 @@ export const extendMiddleware = <
   req.acceptsLanguages = getAcceptsLanguages(req)
 
   req.range = getRangeFromHeader(req)
+  req.xhr = checkIfXMLHttpRequest(req)
+  req.is = reqIs(req)
+
+  req.ip = getIP(req)
+  req.ips = getIPs(req)
+
+  if (settings?.networkExtensions) {
+    req.protocol = getProtocol(req)
+    req.secure = req.protocol === 'https'
+    req.hostname = getHostname(req)
+    req.subdomains = getSubdomains(req, settings.subdomainOffset)
+    req.ip = getIP(req)
+    req.ips = getIPs(req)
+  }
 
   // Response extensions
 
@@ -62,21 +85,16 @@ export const extendMiddleware = <
   res.sendFile = sendFile<Res>(res)
   res.sendStatus = sendStatus(req, res)
   res.json = json<Res>(res)
-
   res.setHeader = setHeader<Res>(res)
   res.set = setHeader<Res>(res)
-
   res.location = setLocationHeader<Req, Res>(req, res)
-
   res.get = getResponseHeader<Res>(res)
-
   res.append = append<Res>(res)
-
   res.render = renderTemplate<RenderOptions, Res>(res, app)
-
   res.links = setLinksHeader<Res>(res)
-
   res.type = setContentType<Res>(res)
+  res.format = formatResponse(req, res, next)
+  res.vary = setVaryHeader(res)
 
   next?.()
 }

extensions/req/headers.ts

@@ -2,6 +2,7 @@ import { Request } from '../../request.ts'
 import { Response } from '../../response.ts'
 import parseRange, { Options } from 'https://esm.sh/range-parser'
 import fresh from 'https://deno.land/x/fresh/mod.ts'
+import { is } from 'https://deno.land/x/type_is/mod.ts'
 
 export const getRequestHeader = (req: Request) => (header: string): string | string[] | null => {
   const lc = header.toLowerCase()
@@ -42,3 +43,7 @@ export const getFreshOrStale = (req: Request, res: Response) => {
 
   return false
 }
+
+export const checkIfXMLHttpRequest = (req: Request) => req.headers.get('X-Requested-With') === 'XMLHttpRequest'
+
+export const reqIs = (req: Request) => (...types: string[]) => is(req.headers.get('content-type') as string, types)

extensions/req/mod.ts

@@ -1,2 +1,3 @@
 export * from './accepts.ts'
 export * from './headers.ts'
+export * from './security.ts'

extensions/req/security.ts

@@ -0,0 +1,60 @@
+import { isIP } from 'https://deno.land/x/isIP/mod.ts'
+import { Request } from '../../request.ts'
+import { compile, proxyaddr, all } from '../../utils/proxyAddr.ts'
+import { Protocol } from '../../request.ts'
+
+export const trustRemoteAddress = (req: Request) => {
+  const val = (req.conn.remoteAddr as Deno.NetAddr).hostname
+
+  if (typeof val === 'function') return val
+
+  if (typeof val === 'boolean' && val === true) return () => true
+
+  if (typeof val === 'number') return (_: unknown, i: number) => (val ? i < val : undefined)
+
+  if (typeof val === 'string') return compile(val.split(',').map((x) => x.trim()))
+
+  return compile(val)
+}
+
+export const getProtocol = (req: Request): Protocol => {
+  const proto = req.proto.includes('https') ? 'https' : 'http'
+
+  const header = (req.get('X-Forwarded-Proto') as string) ?? proto
+  const index = header.indexOf(',')
+
+  if (!trustRemoteAddress(req)) return proto
+
+  // Note: X-Forwarded-Proto is normally only ever a
+  // single value, but this is to be safe.
+
+  return (index !== -1 ? header.substring(0, index).trim() : header.trim()) as Protocol
+}
+
+export const getHostname = (req: Request): string | undefined => {
+  let host: string = req.get('X-Forwarded-Host') as string
+
+  if (!host || !trustRemoteAddress(req)) {
+    host = (req.get('Host') as string) || (req.conn.remoteAddr as Deno.NetAddr).hostname
+  }
+
+  if (!host) return
+
+  // IPv6 literal support
+  const index = host.indexOf(':', host[0] === '[' ? host.indexOf(']') + 1 : 0)
+
+  return index !== -1 ? host.substring(0, index) : host
+}
+export const getIP = (req: Request): string | undefined => proxyaddr(req, trustRemoteAddress(req)).replace(/^.*:/, '') // striping the redundant prefix addeded by OS to IPv4 address
+
+export const getIPs = (req: Request): string[] | undefined => all(req, trustRemoteAddress(req))
+
+export const getSubdomains = (req: Request, subdomainOffset = 2): string[] => {
+  const hostname = getHostname(req)
+
+  if (!hostname) return []
+
+  const subdomains = isIP(hostname) ? [hostname] : hostname.split('.').reverse()
+
+  return subdomains.slice(subdomainOffset)
+}

extensions/res/end.ts

@@ -1,7 +1,7 @@
 import { Request } from '../../request.ts'
 import { Response } from '../../response.ts'
 
-export const end = (req: Request, res: Response) => (body: any) => {
+export const end = (req: Request, res: Response) => (body: any = '') => {
   req.respond({ ...res, body })
   return res
 }

extensions/res/format.ts

@@ -0,0 +1,49 @@
+import { Handler } from 'https://esm.sh/@tinyhttp/router'
+import { normalizeType, normalizeTypes } from './utils.ts'
+import { setVaryHeader } from './headers.ts'
+import { getAccepts } from '../req/mod.ts'
+import { Request as Req } from '../../request.ts'
+import { Response as Res } from '../../response.ts'
+
+export type FormatProps = {
+  default?: () => void
+} & Record<string, Handler>
+
+export type FormatError = Error & {
+  status: number
+  statusCode: number
+  types: ReturnType<typeof normalizeTypes>[]
+}
+
+type next = (err?: FormatError) => void
+
+export const formatResponse = <Request extends Req = Req, Response extends Res = Res, Next extends next = next>(
+  req: Request,
+  res: Response,
+  next: Next
+) => (obj: FormatProps) => {
+  const fn = obj.default
+
+  if (fn) delete obj.default
+
+  const keys = Object.keys(obj)
+
+  const key = keys.length > 0 ? (getAccepts(req)(...keys) as string) : false
+
+  setVaryHeader(res)('Accept')
+
+  if (key) {
+    res.setHeader('Content-Type', normalizeType(key).value)
+    obj[key](req, res, next)
+  } else if (fn) {
+    fn()
+  } else {
+    const err = new Error('Not Acceptable') as FormatError
+    err.status = err.statusCode = 406
+    err.types = normalizeTypes(keys).map((o) => o.value)
+
+    next(err)
+  }
+
+  return res
+}

extensions/res/headers.ts

@@ -1,5 +1,6 @@
 import * as mime from 'https://esm.sh/es-mime-types'
 import { encodeUrl } from 'https://esm.sh/@tinyhttp/encode-url'
+import { vary } from '../../utils/vary.ts'
 import { Response as Res } from '../../response.ts'
 import { Request as Req } from '../../request.ts'
 import { getRequestHeader } from '../req/headers.ts'
@@ -71,6 +72,12 @@ export const setLinksHeader = <Response extends Res = Res>(res: Response) => (li
   return res
 }
 
+export const setVaryHeader = <Response extends Res = Res>(res: Response) => (field: string): Response => {
+  vary<Response>(res, field)
+
+  return res
+}
+
 export const setContentType = <Response extends Res = Res>(res: Response) => (type: string): Response => {
   const ct = type.indexOf('/') === -1 ? mime.lookup(type) : type