wok-server 0.4.13 → 0.6.0

package/src/mvc/render/index.ts

@@ -0,0 +1,4 @@
+export * from './text'
+export * from './json'
+export * from './file'
+export * from './html'

package/src/mvc/render/json.ts

@@ -0,0 +1,24 @@
+import { ServerResponse } from 'http'
+
+/**
+ * 渲染 json 格式数据.
+ * @param response 响应信息
+ * @param json json对象
+ * @param status 状态码，默认 200
+ * @returns
+ */
+export function renderJson(response: ServerResponse, json: any, status = 200) {
+  response.setHeader('content-type', 'application/json; charset=UTF-8')
+  response.statusCode = status
+  response.end(JSON.stringify(json))
+}
+
+/**
+ * 渲染错误信息，json 格式
+ * @param response
+ * @param message
+ * @param status
+ */
+export function renderError(response: ServerResponse, message: string, status = 400) {
+  renderJson(response, { message }, status)
+}

package/src/mvc/render/text.ts

@@ -0,0 +1,14 @@
+import { ServerResponse } from 'http'
+
+/**
+ * 渲染 json 格式数据.
+ * @param response 响应信息
+ * @param text 文本
+ * @param status 状态码，默认 200
+ * @returns
+ */
+export function renderText(response: ServerResponse, text: string, status = 200) {
+  response.setHeader('content-type', 'text/plain; charset=UTF-8')
+  response.statusCode = status
+  response.end(text)
+}

package/src/mvc/router.ts

@@ -0,0 +1,13 @@
+import { ServerExchange } from './exchange'
+
+/**
+ * 路由控制器函数.
+ */
+export interface RouterHandler {
+  (exchange: ServerExchange): Promise<void>
+}
+
+/**
+ * 路由列表.
+ */
+export type Routers = Record<string, RouterHandler>

package/src/mvc/server.ts

@@ -0,0 +1,315 @@
+import { readFileSync } from 'fs'
+import { IncomingMessage, Server, ServerResponse, createServer } from 'http'
+import { Server as HttpsServer, createServer as createHttpsServer } from 'https'
+import { Socket } from 'net'
+import { networkInterfaces } from 'os'
+import { isAbsolute, resolve } from 'path'
+import { getLogger } from '../log'
+import { accessLogInterceptor } from './access-log'
+import { WebConfig, getConfig } from './config'
+import { ServerExchange } from './exchange'
+import { Interceptor } from './interceptor'
+import { renderError } from './render'
+import { RouterHandler, Routers } from './router'
+import { ServerStaticRules, StaticHandler } from './static'
+import { notBlank, validate } from '../validation'
+
+/**
+ * mvc 服务选项
+ */
+export interface WokServerOpts {
+  /**
+   * 路由配置.
+   */
+  routers: Routers
+  /**
+   * 拦截器，在路由处理前可以做一些额外操作.
+   */
+  interceptors?: Interceptor[]
+  /**
+   * 前置控制器，在服务启动之前，对服务做一些额外的操作。比如可以连接 socket.io 或者一些其它
+   * 支持 nodejs 原生 http 服务的组件.
+   * @param server
+   * @returns
+   */
+  preHandler?: (server: Server<any>) => Promise<void>
+  /**
+   * 静态资源配置
+   */
+  static?: ServerStaticRules
+}
+
+function resolvePath(path: string) {
+  if (isAbsolute(path)) {
+    return path
+  }
+  return resolve(process.cwd(), path)
+}
+
+/**
+ * web 服务
+ */
+export class WokServer {
+  private readonly config: WebConfig
+  private readonly server: Server<any> | HttpsServer<any>
+  private readonly interceptors: Interceptor[]
+  private readonly routers: Routers
+  private readonly defaultRouter?: RouterHandler
+  private readonly staticHandler?: StaticHandler
+
+  constructor(private readonly opts: WokServerOpts) {
+    this.config = getConfig()
+    // https
+    let tls:
+      | {
+          key: Buffer
+
+          cert: Buffer
+        }
+      | undefined
+    if (this.config.tlsEnable) {
+      validate(this.config, {
+        tlsCert: [notBlank()],
+        tlsKey: [notBlank()]
+      })
+      tls = {
+        cert: readFileSync(resolvePath(this.config.tlsCert)),
+        key: readFileSync(resolvePath(this.config.tlsKey))
+      }
+    }
+    // 路由
+    this.routers = opts.routers
+    this.defaultRouter = this.routers['*']
+    // 拦截器
+    this.interceptors = []
+    if (this.config.accessLog) {
+      this.interceptors.push(accessLogInterceptor)
+    }
+    if (opts.interceptors) {
+      this.interceptors.push(...opts.interceptors)
+    }
+    // 静态处理
+    if (opts.static) {
+      this.staticHandler = new StaticHandler(opts.static)
+    }
+    // 主服务
+    if (!tls) {
+      this.server = createServer((req, res) => {
+        res.setHeader('Server', 'Wok Server')
+        res.on('error', error => {
+          // 如果响应流发生错误，只能把信息记录下来
+          getLogger().error(`Response Error：${req.url}`, error)
+        })
+        this.handleRequest(req, res).catch(error => {
+          getLogger().error(`Handle request failed：${req.url}`, error)
+          if (!res.writableEnded) {
+            // 响应 500
+            renderError(res, error.message ? error.message : 'Internal Server Error', 500)
+          }
+        })
+      })
+    } else {
+      this.server = createHttpsServer(
+        {
+          key: tls.key,
+          cert: tls.cert
+        },
+        (req, res) => {
+          res.setHeader('Server', 'Wok Server')
+          res.on('error', error => {
+            // 如果响应流发生错误，只能把信息记录下来
+            getLogger().error(`Response Error：${req.url}`, error)
+          })
+          this.handleRequest(req, res).catch(error => {
+            getLogger().error(`Handle request failed：${req.url}`, error)
+            if (!res.writableEnded) {
+              // 响应 500
+              renderError(res, error.message ? error.message : 'Internal Server Error', 500)
+            }
+          })
+        }
+      )
+    }
+    this.server.setTimeout(this.config.timeout)
+    this.server.on('timeout', (socket: Socket) => {
+      socket.end(
+        'HTTP/1.1 408 Timeout\r\ncontent-type: application/json; charset=utf-8\r\n\r\n{"message":"Request timeout"}'
+      )
+    })
+  }
+
+  /**
+   * 处理请求，完成拦截器和路由的流程.
+   *
+   * @param req
+   * @param res
+   */
+  private async handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+    req.socket.remoteAddress
+    const { method } = req
+    // cros 支持
+    res.setHeader('Access-Control-Allow-Origin', this.config.corsAllowOrigin)
+    res.setHeader('Access-Control-Allow-Headers', this.config.corsAllowHeaders)
+    res.setHeader('Access-Control-Allow-Methods', this.config.corsAllowMethods)
+    if (method === 'OPTIONS') {
+      res.statusCode = 200
+      res.end()
+      return
+    }
+    const exchange = new ServerExchange(req, res)
+    // 顺序执行拦截器
+    await this.handleInterceptor(0, exchange, req, res)
+  }
+
+  /**
+   * 处理拦截器.
+   * @param idx 当前要执行的拦截器下标
+   * @param exchange 传输对象
+   * @param req
+   * @param res
+   */
+  private async handleInterceptor(
+    idx: number,
+    exchange: ServerExchange,
+    req: IncomingMessage,
+    res: ServerResponse
+  ) {
+    const interceptor = this.interceptors[idx]
+    // 到最后一个了，那么执行路由处理
+    if (!interceptor) {
+      await this.handleRouter(exchange)
+      return
+    }
+    await interceptor(exchange, () => this.handleInterceptor(idx + 1, exchange, req, res))
+  }
+
+  /**
+   * 处理路由.
+   * @param exchange
+   * @param routers
+   * @param staticSettings
+   * @returns
+   */
+  private async handleRouter(exchange: ServerExchange) {
+    const url = exchange.request.url
+    if (url === undefined) {
+      return
+    }
+    // 判定路由
+    const idx = url.indexOf('?')
+    let path = idx === -1 ? url : url.substring(0, idx)
+    const router = this.routers[path]
+    if (!router) {
+      // 路由找不不到，尝试静态文件
+      if (this.staticHandler) {
+        const method = (exchange.request.method || '').toLowerCase()
+        if (method === 'head') {
+          if (await this.staticHandler.handleHead(path, exchange.response)) {
+            return
+          }
+        }
+        if (method === 'get') {
+          if (await this.staticHandler.handleGet(exchange.request, exchange.response, path)) {
+            return
+          }
+        }
+      }
+      this.respond404(exchange, path)
+      return
+    }
+    // 执行路由
+    await router(exchange)
+    // 在路由顺利处理的情况下，如果 res 没有 end ，就表示响应没有完成
+    // 也就是说路由没有做响应处理，或处理没有完成就结束了，给予错误提示
+    if (!exchange.response.writableEnded) {
+      throw new Error(`RouterHandler unresponsive, url: ${url}`)
+    }
+  }
+
+  /**
+   * 404响应
+   *
+   * @param exchange
+   * @param path
+   */
+  private async respond404(exchange: ServerExchange, path: string) {
+    if (this.defaultRouter) {
+      await this.defaultRouter(exchange)
+    } else {
+      exchange.respondErrMsg(`${path} not found`, 404)
+    }
+  }
+
+  /**
+   * 启动
+   */
+  async start() {
+    if (this.opts.preHandler) {
+      await this.opts.preHandler(this.server)
+    }
+    await new Promise<void>((resolve, reject) => {
+      this.server.on('error', e => {
+        if ((e as any).code === 'EADDRINUSE') {
+          reject(`Port ${this.config.port} is already in use.`)
+        } else {
+          reject(e)
+        }
+      })
+      this.server.listen(this.config.port, resolve)
+    })
+    console.log('App running at: ')
+    let portOmitted =
+      (this.server instanceof HttpsServer && this.config.port === 443) ||
+      (this.server instanceof Server && this.config.port === 80)
+    this.getIpv4List().forEach(ip => {
+      if (portOmitted) {
+        console.log(`http://${ip}`)
+      } else {
+        console.log(`http://${ip}:${this.config.port}`)
+      }
+    })
+  }
+
+  /**
+   * 获取 ipv4 地址列表
+   * @returns
+   */
+  private getIpv4List() {
+    const ifs = networkInterfaces()
+    const res: string[] = []
+    for (const name in ifs) {
+      const list = ifs[name]
+      if (!list) {
+        continue
+      }
+      res.push(...list.filter(info => info.family === 'IPv4').map(info => info.address))
+    }
+    return res
+  }
+  /**
+   * 删除服务器端静态资源缓存
+   * @param path
+   */
+  removeServerStaticCache(path: string) {
+    if (this.staticHandler) {
+      this.staticHandler.removeServerCache(path)
+    }
+  }
+  /**
+   * 停止
+   */
+  async stop() {
+    if (!this.server.listening) {
+      return
+    }
+    await new Promise<void>((res, rej) => {
+      this.server.close(err => {
+        if (err) {
+          rej(err)
+        } else {
+          res()
+        }
+      })
+    })
+  }
+}

package/src/mvc/static/header.ts

@@ -0,0 +1,86 @@
+import { IncomingHttpHeaders } from 'http'
+/**
+ * 解析 range 消息头，如果解析失败，返回 null
+ */
+function parseRange(rangeHeader: string): null | { start: number; end?: number } {
+  // 解析，range 示例：bytes=200-1000, 2000-6576, 19000-
+  // 多段的情况，暂时不做支持，非常麻烦，段数多还可能会有效率问题
+  // 如果不是字节范围不是以字节为单位，暂时也不做支持
+  const ranges = rangeHeader.split(',')
+  if (!ranges.length) {
+    return null
+  }
+  let range = ranges[0].trim()
+  if (!range.startsWith('bytes=')) {
+    return null
+  }
+  range = range.substring(6)
+  const strs = range.split('-')
+  let start = strs[0] ? parseInt(strs[0], 10) : NaN
+  let end = strs[1] ? parseInt(strs[1], 10) : undefined
+  return { start, end }
+}
+
+/**
+ * 静态资源消息头信息
+ */
+export interface StaticHeaders {
+  /**
+   * If-Modified-Since 消息头，测试文件是否在某个时间后修改后
+   */
+  ifModifiedSince?: Date
+  /**
+   * 文件部分读取
+   */
+  range?: { start: number; end?: number }
+  /**
+   * 是否接受 gzip 压缩，如果支持则压缩后返回
+   */
+  gzip: boolean
+}
+
+/**
+ * 解析消息头，返回静态文件处理需要的信息
+ * @param headers
+ */
+export function parseHeaders(headers: IncomingHttpHeaders) {
+  // 是否支持 gzip
+  const acceptEncoding = headers['accept-encoding'] as string
+  let acceptGzip = false
+  if (acceptEncoding) {
+    // Accept-Encoding: br;q=1.0, gzip;q=0.8, *;q=0.1
+    const acceptEncodings = acceptEncoding
+      .trim()
+      .split(',')
+      .map(item => item.trim())
+      .map(item => item.split(';')[0])
+    if (acceptEncodings.includes('gzip') || acceptEncodings.includes('*')) {
+      acceptGzip = true
+    }
+  }
+  let res: StaticHeaders = {
+    gzip: acceptGzip
+  }
+
+  // 支持 If-Modified-Since
+  // 由于只是简单的文件映射，没有 etag，不能支持 If-None-Match
+  const ifModifiedSince = headers['if-modified-since']
+  if (ifModifiedSince) {
+    const modifiedSince = new Date(ifModifiedSince)
+    if (modifiedSince instanceof Date && !isNaN(modifiedSince.getTime())) {
+      res.ifModifiedSince = modifiedSince
+    }
+  }
+
+  // 支持 Range
+  // https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/Range
+  const rangeHeader = headers['range']
+  if (rangeHeader) {
+    const rangeRes = parseRange(rangeHeader)
+    if (rangeRes) {
+      res.range = rangeRes
+    }
+  }
+
+  return res
+}

package/src/mvc/static/index.ts

@@ -0,0 +1,3 @@
+export * from './mime-type'
+export * from './header'
+export * from './static-handler'

package/src/mvc/static/mime-type.ts

@@ -0,0 +1,81 @@
+export const MIME_TYPES: Record<string, string> = {
+  aac: 'audio/aac',
+  abw: 'application/x-abiword',
+  arc: 'application/x-freearc',
+  avi: 'video/x-msvideo',
+  azw: 'application/vnd.amazon.ebook',
+  bin: 'application/octet-stream',
+  bmp: 'image/bmp',
+  bz: 'application/x-bzip',
+  bz2: 'application/x-bzip2',
+  csh: 'application/x-csh',
+  css: 'text/css',
+  csv: 'text/csv',
+  doc: 'application/msword',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  eot: 'application/vnd.ms-fontobject',
+  epub: 'application/epub+zip',
+  gif: 'image/gif',
+  htm: 'text/html',
+  html: 'text/html',
+  ico: 'image/vnd.microsoft.icon',
+  ics: 'text/calendar',
+  jar: 'application/java-archive',
+  jpeg: 'image/jpeg',
+  jpg: 'image/jpeg',
+  js: 'text/javascript',
+  json: 'application/json',
+  jsonld: 'application/ld+json',
+  mid: 'audio/midi',
+  midi: 'audio/midi',
+  mjs: 'text/javascript',
+  mp3: 'audio/mpeg',
+  mpeg: 'video/mpeg',
+  mpkg: 'application/vnd.apple.installer+xml',
+  odp: 'application/vnd.oasis.opendocument.presentation',
+  ods: 'application/vnd.oasis.opendocument.spreadsheet',
+  odt: 'application/vnd.oasis.opendocument.text',
+  oga: 'audio/ogg',
+  ogv: 'video/ogg',
+  ogx: 'application/ogg',
+  otf: 'font/otf',
+  png: 'image/png',
+  pdf: 'application/pdf',
+  ppt: 'application/vnd.ms-powerpoint',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  rar: 'application/x-rar-compressed',
+  rtf: 'application/rtf',
+  sh: 'application/x-sh',
+  svg: 'image/svg+xml',
+  swf: 'application/x-shockwave-flash',
+  tar: 'application/x-tar',
+  tif: 'image/tiff',
+  tiff: 'image/tiff',
+  ttf: 'font/ttf',
+  txt: 'text/plain',
+  vsd: 'application/vnd.visio',
+  wav: 'audio/wav',
+  weba: 'audio/webm',
+  webm: 'video/webm',
+  webp: 'image/webp',
+  woff: 'font/woff',
+  woff2: 'font/woff2',
+  xhtml: 'application/xhtml+xml',
+  xls: 'application/vnd.ms-excel',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  xml: 'application/xml',
+  xul: 'application/vnd.mozilla.xul+xml',
+  zip: 'application/zip',
+  '3gp': 'video/3gpp',
+  '3g2': 'video/3gpp2',
+  '7z': 'application/x-7z-compressed'
+}
+
+export function decideContentType(fileName: string): string | undefined {
+  const idx = fileName.lastIndexOf('.')
+  if (idx === -1) {
+    return undefined
+  }
+  const suffix = fileName.substring(idx + 1)
+  return MIME_TYPES[suffix]
+}

package/src/mvc/static/server-cache-config.ts

@@ -0,0 +1,92 @@
+import { generateConfig } from '../../config'
+import { PropValidator, max, min, notNull } from '../../validation'
+
+/**
+ * 服务器缓存配置
+ * Server Cache Configuration
+ */
+export interface ServerCacheConfig {
+  /**
+   * Enable or disable caching,default is false (disabled)
+   */
+  enable: boolean
+  /**
+   *  The maximum age of the cache in seconds
+   */
+  maxAge: number
+  /**
+   * The maximum size of the cache in bytes
+   * or a string representing a number followed by a unit of measure (e.g. 100k, 10m, 1g)
+   */
+  maxSize: number | string
+  /**
+   * The maximum size of a file in the cache in bytes
+   * or a string representing a number followed by a unit of measure (e.g. 100k, 10m, 1g)
+   */
+  maxFileSize: number | string
+}
+
+export function parseSize(size: number | string): number {
+  if (typeof size === 'number') {
+    return size
+  }
+  const match = size.match(/^(\d+)([kmg]?)$/i)
+  if (!match) {
+    throw new Error(`Invalid size: ${size}`)
+  }
+  const [, num, unit] = match
+  let sizeNum = parseInt(num, 10)
+  switch (unit.toLowerCase()) {
+    case 'k':
+      sizeNum *= 1024
+      break
+    case 'm':
+      sizeNum *= 1024 * 1024
+      break
+    case 'g':
+      sizeNum *= 1024 * 1024 * 1024
+      break
+    default:
+      break
+  }
+  return sizeNum
+}
+
+function validateSize(max: number | string): PropValidator<number | string> {
+  const maxNum = parseSize(max)
+  const validator = 'size'
+  return val => {
+    if (val === null || val === undefined) {
+      return { ok: true }
+    }
+    const sizeNum = typeof val === 'number' ? val : parseSize(val)
+    if (sizeNum < 1) {
+      return { ok: false, validator, message: `size must greater than 1` }
+    }
+    if (sizeNum > maxNum) {
+      return { ok: false, validator, message: `size must less than ${max}` }
+    }
+    return { ok: true }
+  }
+}
+/**
+ * 获取缓存的配置信息
+ * @returns
+ */
+export function getConfig() {
+  return generateConfig<ServerCacheConfig>(
+    {
+      enable: false,
+      maxAge: 600,
+      maxSize: '100m',
+      maxFileSize: '10m'
+    },
+    'SERVER_STATIC_CACHE',
+    {
+      enable: [notNull()],
+      maxAge: [notNull(), min(1), max(31536000)],
+      maxSize: [notNull(), validateSize('1024g')],
+      maxFileSize: [notNull(), validateSize('1g')]
+    }
+  )
+}