topbit 1.0.0 → 3.0.0

package/src/extends/sni.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const fs = require('node:fs')
+const tls = require('node:tls')
+
+class SNI {
+  constructor(certs = {}) {
+    this.certs = {}
+
+    if (typeof certs !== 'object') {
+      throw new Error('必须传递key-value形式的配置，key是域名，value是证书路径')
+    }
+
+    let t = '';
+    for (let h in certs) {
+      t = certs[h]
+
+      if (t.key === undefined || t.cert === undefined) {
+        console.error(`${h} 没有设置key和cert`)
+        continue
+      }
+
+      try {
+        this.certs[h] = {
+          key : fs.readFileSync(t.key),
+          cert : fs.readFileSync(t.cert)
+        }
+      } catch (err) {
+        console.error(h, err.message)
+        continue
+      }
+
+    }
+  }
+
+  callback() {
+    return (servername, cb) => {
+      return cb(null, tls.createSecureContext(this.certs[servername]))
+    }
+  }
+
+  init(app) {
+    app.config.server.SNICallback = this.callback()
+  }
+
+}
+
+module.exports = SNI

package/src/extends/sse.js

@@ -0,0 +1,293 @@
+'use strict'
+
+function fmtMessage(msg, withEnd=true) {
+  let text = ''
+
+  if (Array.isArray(msg)) {
+    let textarr = []
+    
+    for (let m of msg) {
+      text = fmtMessage(m, false)
+      text && textarr.push(text)
+    }
+    if (textarr.length === 0) return ''
+
+    return textarr.join('\n\n') + '\n\n'
+  }
+
+  if (msg === null || msg === undefined || msg === '') {
+    return ''
+  }
+
+  let typ = typeof msg
+
+  if (typ === 'number') {
+    msg = `${msg}`
+    typ = 'string'
+  }
+
+  if (typ === 'object') {
+    if (!(msg.event || msg.data || msg.retry || msg.id)) return ''
+    
+    if (msg.data === undefined) msg.data = ''
+
+    let datatype = typeof msg.data
+
+    switch (datatype) {
+      case 'number':
+        msg.data = msg.data.toString()
+        break
+      case 'object':
+        msg.data = JSON.stringify(msg.data).replaceAll('\n', '%0A')
+        break
+      case 'function':
+        msg.data = msg.data.toString().replaceAll('\n', '%0A')
+        break
+      case 'string':
+        msg.data = msg.data.replaceAll('\n', '%0A')
+        break
+
+      default:
+        msg.data = `${msg.data}`
+    }
+
+    text = `event: ${msg.event || 'message'}\ndata: ${msg.data}\n`
+    if (msg.id) {
+      text += `id: ${msg.id}\n`
+    }
+
+    if (msg.retry) {
+      text += `retry: ${msg.retry}\n`
+    }
+  } else if (typ === 'string') {
+    if (msg[0] !== ':') {
+      text = `data: ${msg.replaceAll('\n', '%0A')}\n`
+    } else {
+      text = msg.replaceAll('\n', '%0A') + '\n'
+    }
+  } else if (typ === 'function') {
+    text = `event: function\ndata: ${msg.toString().replaceAll('\n', '%0A')}\n`
+  }
+
+  if (withEnd) {
+    text += `\n\n`
+  }
+
+  return text
+}
+
+class SSE {
+
+  constructor(options = {}) {
+    this.timer = null
+    this.handle = null
+    this.timeSlice = 1000
+
+    this.retry = 0
+    this.timeout = 15000
+
+    this.fmtMsg  = fmtMessage
+
+    this.handleClose = null
+    this.handleError = null
+
+    this.mode = 'timer'
+
+    for (let k in options) {
+      switch (k) {
+        case 'timeSlice':
+        case 'timeout':
+        case 'retry':
+          if (typeof options[k] === 'number' && options[k] >= 0) {
+            this[k] = options[k]
+          }
+          break
+
+        case 'handle':
+        case 'handleClose':
+        case 'handleError':
+          if (typeof options[k] === 'function') this[k] = optionsp[k]
+          break
+
+        case 'mode':
+          if (['timer', 'generator', 'yield'].indexOf(options[k]) >= 0)
+            this[k] = options[k]
+          break
+      }
+    }
+
+  }
+
+  async interval(ctx) {
+    if (!this.handle || typeof this.handle !== 'function') {
+      throw new Error('请设置handle为要处理的函数，然后再次运行。')
+    }
+
+    let self = this
+
+    if (self.timer) {
+      clearInterval(this.timer)
+      this.timer = null
+    }
+
+    return new Promise((rv, rj) => {
+      ctx.res.on('error', err => {
+        clearInterval(self.timer)
+        self.timer = null
+        rj(err)
+      })
+
+      ctx.res.on('close', () => {
+        clearInterval(self.timer)
+        self.timer = null
+        rv('sse closed')
+      })
+
+      self.timer = setInterval(async () => {
+        ctx.box.sseCount += 1
+        if (self.timeout > 0 && ctx.box.sseCount * self.timeSlice > self.timeout) {
+          if (self.retry > 0) {
+            ctx.sendmsg({data: 'timeout', retry: self.retry})
+          }
+          return ctx.res.end()
+        }
+
+        try {
+          await self.handle(ctx)
+        } catch (err) {
+          clearInterval(self.timer)
+          self.timer = null
+          rj(err)
+        }
+      }, self.timeSlice || 1000)
+    })
+
+  }
+
+  async moment(t) {
+    return new Promise((rv) => {
+      setTimeout(rv, t)
+    })
+  }
+
+  gn(ctx) {
+    if (!this.handle || typeof this.handle !== 'function') {
+      throw new Error('请设置handle为要处理的函数，然后再次运行。')
+    }
+
+    let self = this
+
+    ctx.box.sseNext = true
+
+    ctx.res.on('error', err => {
+      ctx.box.sseNext = false
+      ctx.box.sseError = err
+    })
+
+    ctx.res.on('close', () => {
+      ctx.box.sseNext = false
+    })
+
+    return async function * () {
+        while (true) {
+          let tm = Date.now()
+
+          if (self.timeout > 0 && (tm - ctx.box.sseTime) > self.timeout) {
+            if (self.retry > 0) {
+              ctx.sendmsg({data: 'timeout', retry: self.retry})
+            }
+            return
+          }
+          ctx.box.sseCount += 1
+          try {
+            await self.handle(ctx)
+          } catch (err) {
+            ctx.box.sseNext = false
+            ctx.box.sseError = err
+          }
+
+          if (ctx.box.sseNext) {
+            yield tm
+          } else {
+            break
+          }
+        }
+    }
+
+  }
+
+  async rungn(ctx) {
+    let yn = this.gn(ctx)
+    let r
+    let y = yn()
+
+    while (true) {
+      r = await y.next()
+      
+      if (r.done) break
+
+      if (this.timeSlice > 0) await this.moment(this.timeSlice)
+    }
+
+    if (ctx.box.sseError) {
+      if (this.handleError && typeof this.handleError === 'function')
+        this.handleError(ctx.box.sseError, ctx)
+      else throw ctx.box.sseError
+    } else if (this.handleClose && typeof this.handleClose === 'function') {
+      this.handleClose(ctx)
+    }
+  }
+
+  autoRun(ctx) {
+    if (this.mode === 'timer') {
+      return this.interval(ctx)
+                .then(data => {
+                  if (typeof this.handleClose === 'function') this.handleClose(ctx)
+                })
+                .catch(err => {
+                  if (typeof this.handleError === 'function') {
+                    this.handleError(err, ctx)
+                  } else {
+                    throw err
+                  }
+                })
+    } else {
+      ctx.box.sseTime = Date.now()
+      return this.rungn(ctx)
+    }
+  }
+
+  mid() {
+    let self = this
+
+    return async (ctx, next) => {
+      ctx.setHeader('content-type', 'text/event-stream;charset=utf-8').sendHeader()
+      ctx.sse = self
+      //用于统计是否超时断开并发送retry
+      ctx.box.sseCount = 0
+      if (!ctx.sendmsg || typeof ctx.sendmsg !== 'function') {
+        ctx.sendmsg = (msg, cb=undefined) => {
+          let emsg = fmtMessage(msg)
+          if (emsg) return ctx.res.write(emsg, cb)
+        }
+      }
+
+      ctx.res.setTimeout(self.timeout, () => {
+        if (ctx.res.writable) ctx.res.end()
+      })
+
+      //http2协议需要设置session超时，否则如果默认的服务超时设置比self.timeout短，会导致无法收到消息。
+      if (ctx.major == 2 && ctx.res.session && ctx.res.session.listenerCount) {
+        //http2的session会保持连接，如果stream超时关闭后，session可能会维持连接，此时有可能会复用session。
+        if (ctx.res.session.listenerCount('timeout') < 2) {
+          ctx.res.session.setTimeout(self.timeout, () => {})
+        }
+      }
+
+      await self.autoRun(ctx)
+    }
+  }
+
+}
+
+module.exports = SSE

package/src/extends/timing.js

@@ -0,0 +1,111 @@
+'use strict'
+
+const fs = require('node:fs')
+
+class Timing {
+
+  constructor(options = {}) {
+
+    /**
+     * route保存所有路由的最近耗时记录。
+     * maxLimit是保存记录上限。
+     */
+
+    this.route = {
+      GET  : new Map(),
+      POST : new Map(),
+      PUT  : new Map(),
+      DELETE : new Map(),
+      OPTIONS : new Map(),
+      PATCH : new Map()
+    }
+
+    this.maxLimit = 100
+
+    this.test = false
+
+    this.logfile = ''
+
+    if (typeof options !== 'object') {
+      options = {}
+    }
+
+    for (let k in options) {
+      switch (k) {
+        case 'test':
+          this.test = options[k]
+          break
+          
+        case 'logfile':
+          this.logfile = options[k]
+          break
+      }
+    }
+
+  }
+
+  mid() {
+    let self = this
+
+    return async (c, next) => {
+
+      let start_time = Date.now()
+
+      await next()
+
+      let end_time = Date.now()
+
+      let time_consume = end_time - start_time
+
+      if (self.route[c.method] !== undefined) {
+        if (!self.route[c.method].has(c.routepath)) {
+          self.route[c.method].set(c.routepath, {
+            total : 1,
+            consume: time_consume
+          })
+        } else {
+          let t = self.route[c.method].get(c.routepath)
+          if (t.total > self.maxLimit) {
+            t.total = 0
+            t.consume = 0
+          }
+
+          t.total += 1
+          t.consume += time_consume
+
+        }
+
+      }
+
+      let last = self.route[c.method].get(c.routepath)
+
+      if (self.test) {
+        
+        console.log(c.method, c.path, time_consume, 'ms')
+
+        console.log(c.method, c.path,'\n',
+          `  Count: ${last.total}  Total: ${last.consume} ms `,
+          `Average: ${(last.consume/last.total).toFixed(2)} ms`
+        )
+      }
+
+      if (self.logfile) {
+        
+        let log_text = `${c.method} - ${c.path} - count: ${last.total}, `
+                        + `total: ${last.consume}ms, `
+                        + `average: ${(last.consume/last.total).toFixed(2)}ms\n`
+
+        fs.writeFile(self.logfile, log_text, {flag: 'a+'}, err => {
+          if (self.test && err) {
+            console.error(err)
+          }
+        })
+      }
+
+    }
+
+  }
+
+}
+
+module.exports = Timing

package/src/extends/tofile.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const fs = require('node:fs')
+const crypto = require('node:crypto')
+
+function extName(fname) {
+  let ind = fname.length - 2
+
+  while (ind > 0 && fname[ind] !== '.') {
+    ind -= 1
+  }
+
+  if (ind <= 0) return ''
+
+  return fname.substring(ind)
+}
+
+let fmtbits = (n) => {
+  return n < 10 ? `0${n}` : n
+}
+
+function makeName(filename = '') {
+  let tm = new Date()
+
+  let orgname = `${tm.getFullYear()}-${fmtbits(tm.getMonth()+1)}-${fmtbits(tm.getDate())}_`
+      + `${fmtbits(tm.getHours())}-${fmtbits(tm.getMinutes())}-${fmtbits(tm.getSeconds())}`
+      + `_${tm.getMilliseconds()}${parseInt(Math.random() * 1000) + 1}${parseInt(Math.random() * 100000) + 10000}`
+
+  if (filename) return (orgname + extName(filename))
+
+  return orgname
+}
+
+async function moveFile(target, filename = null) {
+  if (!this || !this.rawBody) return false
+
+  if (!filename) filename = makeName(this.filename || '')
+  
+  let ds = ''
+  if (target[target.length-1] !== '/') ds = '/'
+
+  let pathfile = `${target}${ds}${filename}`
+
+  let fd = await new Promise((rv, rj) => {
+      fs.open(pathfile, 'w+', 0o644, (err, fd) => {
+        if (err) {
+          rj(err)
+        } else {
+          rv(fd)
+        }
+      })
+  })
+
+  return new Promise((rv, rj) => {
+    fs.write(fd, this.rawBody, this.start, this.length,
+      (err, bytesWritten, buffer) => {
+        if (err) {
+          rj(err)
+        } else {
+          rv(filename)
+        }
+      })
+  })
+  .finally(() => {
+    fs.close(fd, (err) => {})
+  })
+
+}
+
+function getFile(name, ind=0) {
+  if (!this || !this.files) return null
+
+  if (this.files[name] === undefined) {
+    return ind < 0 ? [] : null
+  }
+
+  if (ind >= this.files[name].length) {
+    return null
+  }
+
+  let flist = this.files[name]
+
+  if (ind < 0) {
+    for (let i = 0; i < flist.length; i++) {
+      if (flist[i].toFile === undefined) {
+        flist[i].rawBody = this.rawBody
+        flist[i].toFile = moveFile
+      }
+    }
+    return flist
+  }
+
+  if (flist[ind].toFile === undefined) {
+    flist[ind].rawBody = this.rawBody
+    flist[ind].toFile = moveFile
+  }
+
+  return flist[ind]
+}
+
+
+class ToFile {
+
+  constructor() {
+
+  }
+
+  mid() {
+    let self = this
+    return async (c, next) => {
+      if (!c.isUpload) {
+        return await next()
+      }
+
+      c.getFile = getFile
+      await next()
+    }
+
+  }
+
+}
+
+module.exports = ToFile